C语言 VR全景图片 dedecms Java Spring SCI Android开发 mAPI x86 grid grunt vue的优点 vue手册 bootstrap模板 网盘源码 nginx默认端口号 bentley软件介绍 安卓虚拟机运行windows mysql或者条件 数据库教程 python的random函数 python文件操作 python的安装 python学习网站 javasocket java怎么编程 java日期格式化 liunx命令大全 php入门例子 python源码下载 rndis驱动下载 kms神龙 地下城怎么双开 x64dbg 桌面数字时钟 c4d挤压怎么用 eagle软件 ios12录屏 r330不能识别墨盒 jq循环 速查表
当前位置: 首页 > 学习教程  > 编程语言

编译选项中的硬浮点与软浮点区别

2020/9/19 14:48:50 文章标签:

一、硬浮点与软浮点

1. 硬浮点

编译器将代码直接编译成硬件浮点协处理器(浮点运算单元FPU)能识别的指令,这些指令在执行的时候ARM核直接把它转给协处理器执行。FPU 通常有一套额外的寄存器来完成浮点参数传递和运算。使用实际的硬件浮点运算单元(FPU)会带来性能的提升

2. 软浮点

编译器把浮点运算转成浮点运算的函数调用和库函数调用(即用整数运算模拟浮点运算),没有FPU的指令调用,也没有浮点寄存器的参数传递。浮点参数的传递也是通过ARM寄存器或者堆栈完成。现在的Linux系统默认编译选择使用hard-float,如果系统没有任何浮点处理器单元,这就会产生非法指令和异常。因而一般的系统镜像都采用软浮点以兼容没有VFP的处理器。

3. ARM软浮点与硬浮点编译

出于低功耗、封装限制等种种原因,以前的一些ARM处理器没有独立的硬件浮点运算单元,需要用软件来实现浮点运算。随着技术发展,现在高端的ARM处理器基本都具备了硬件执行浮点操作的能力。 新旧两种架构之间的差异,就产生了两个不同的接口 – 软浮点与硬浮点。

编译选项:

-mfpu =name(neon or vfp)指定FPU 单元

-mfloat-abi= name(soft、hard、 softfp):指定软件浮点或硬件浮点或 兼容软浮点调用接口

-mfpu可以指定使用FPU单元类型,以ARM A76为例有两种:VFP和Neon

在这里插入图片描述

VFP与Neon

  • VFP (vector floating-point)

    VFP是一个按顺序工作的浮点协处理器, 它对一组输入执行一个操作并返回一个输出。目的是加快浮点计算,支持单精度和双精度浮点。

  • NEON

    Neon是SIMD (Single Instruction Multiple Data) , 支持单指令多数据操作,意味着在执行一条指令期间,将对多达16个数据集并行执行相同的操作,支持整数和单精度浮点数向量化(并行)操作。

  • 二者区别

    VFP 支持单精度和双精度浮点,顺序执行,目的加快浮点计算

    Neon 是SIMD,支持单指令多数据操作,支持整数和单精度浮点数向量化(并行)操作,不支持双浮点 。Neon最大的好处是如果想要执行矢量操作,如对视频的编码/解码, 它可以并行执行单精度浮点(float)操作。 从而提高对视频编码/解码性能

    VFP 和Neon是共用浮点寄存器,只是执行的指令不同。

soft、hard、 softfp

在有fpu的情况下,可以通过-mfloat-abi来指定使用哪种,有如下三种值:

  • **soft:**不用fpu计算,即使有fpu浮点运算单元也不用。
  • armel:(arm eabi little endian) 也即softfp,用fpu计算(即会将浮点运算编译成对应的浮点指令),但是传参数用普通寄存器传,这样中断的时候,只需要保存普通寄存器,中断负荷小,但是参数需要转换成浮点的再计算。
  • armhf:(arm hard float)也即hard,用fpu计算,传参数用fpu中的浮点寄存器传,省去了转换性能最好,但是中断负荷高。

而arm64,64位的arm默认就是hard float的,因此不需要hf的后缀。kernel、rootfs和app编译的时候,指定的必须保持一致才行。

使用softfp模式,会存在不必要的浮点到整数、整数到浮点的转换。而使用hard模式,在每次浮点相关函数调用时,平均能节省20个CPU周期。

4. ARM启用硬浮点运算

需要使用硬浮点,需要内核开启对硬浮点支持,同时编译时要使用上面的softfp或hard,才可以使用FPU/Neon进行计算。

二、 在内核代码中使用浮点问题

1. ARM64的用户空间进程切换 ---- 浮点寄存器切换

ARM64,默认使用的是硬浮点,在进程切换时会涉及对浮点寄存器的操作。

对于ARM64而言,进程切换的context包括:

(1)通用寄存器

(2)浮点寄存器

(3)地址空间寄存器(ttbr0_el1和ttbr1_el1)

(4)其他寄存器(ASID、thread process ID register等)

Path:arch/arm64/kernel/process.c
/*
 * Thread switching.
 */
__notrace_funcgraph struct task_struct *__switch_to(struct task_struct *prev,
				struct task_struct *next)
{
	struct task_struct *last;
<span class="token function">fpsimd_thread_switch</span><span class="token punctuation">(</span>next<span class="token punctuation">)</span><span class="token punctuation">;</span> 
<span class="token comment">/*fp是float-point的意思,和浮点运算相关。fpsimd_thread_switch
其实就是把当前FPSIMD的状态保存到了内存中(task.thread.fpsimd_state),
从要切入的next进程描述符中获取FPSIMD状态,并加载到CPU上。*/</span>
<span class="token function">tls_thread_switch</span><span class="token punctuation">(</span>next<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token function">hw_breakpoint_thread_switch</span><span class="token punctuation">(</span>next<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token function">contextidr_thread_switch</span><span class="token punctuation">(</span>next<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>
<span class="token keyword">return</span> last<span class="token punctuation">;</span>

}
-
Path:arch/arm64/kernel/fpsimd.c
void fpsimd_thread_switch(struct task_struct next)
{
......
/ Save unsaved fpsimd state, if any: /
fpsimd_save(); //这里将struct fpsimd_state保存到通用寄存器X0中
......
}
-
Path:arch/arm64/kernel/entry-fpsimd.S
/ Save the FP registers. x0 - pointer to struct fpsimd_state*/
ENTRY(fpsimd_save_state)
fpsimd_save x0, 8
ret
ENDPROC(fpsimd_save_state)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
2. 内核使用浮点

关于内核使用浮点, Robert Love’s 《Linux Kernel Development》(Linux内核设计与实现)书中提到

No (Easy) Use of Floating Point

When a user-space process uses floating-point instructions, the kernel manages the transition from integer to floating point mode. What the kernel has to do when using floating-point instructions varies by architecture, but the kernel normally catches a trap and then initiates the transition from integer to floating point mode.

Unlike user-space, the kernel does not have the luxury of seamless support for floating point because it cannot easily trap itself. Using a floating point inside the kernel requires manually saving and restoring the floating point registers, among other possible chores. The short answer is: Don’t do it! Except in the rare cases, no floating-point operations are in the kernel.

后面这句话提到如果内核使用浮点则需要保存恢复浮点寄存器等其他杂项,这样会导致内核性能下降,所以一般不建议使用浮点,除非特殊情况。

但是Robert Love’s在这里并没有讨论如何在内核中正确使用浮点,以及未正确使用浮点可能会出现什么问题。**当你需要在内核中使用浮点,如果按照用户空间的写法可能会出现一些意想不到的情况。如:程序Crash,内存越界、访问非法内存地址,浮点计算出错等稀奇古怪的问题。出现这种问题的原因是:内核由于性能原因,在内核运行的代码,内核在进行上下文切换时,不会主动保存和恢复浮点寄存器。**这样可能会导致内核在进行浮点运算时,可能会破坏此时用户空间的浮点寄存器状态,导致用户空间的fpsimd_state状态异常,随后程序的行为将变的不可控。

  • 如何在内核使用浮点

    在内核中使用浮点,在不同架构下会有不同操作流程。这部分需要查阅内核文档,如在X86上要用 kernel_fpu_begin()/kernel_fpu_end(),在arm上用 kernel_neon_begin()/ kernel_neon_end()。但并非在使用浮点时简单的使用上面代码就可以,以arm为例,内核文档里介绍了为何要使用该函数,以及如何使用

    https://www.kernel.org/doc/Documentation/arm/kernel_mode_neon.rst
    ================
    Kernel mode NEON
    ================
    

TL;DR summary
-
Use only NEON instructions, or VFP instructions that don’t rely on support
code
Isolate your NEON code in a separate compilation unit, and compile it with
‘-march=armv7-a -mfpu=neon -mfloat-abi=softfp’
Put kernel_neon_begin() and kernel_neon_end() calls around the calls into your
NEON code
Don’t sleep in your NEON code, and be aware that it will be executed with
preemption disabled

Introduction

It is possible to use NEON instructions (and in some cases, VFP instructions) in
code that runs in kernel mode. However, for performance reasons, the NEON/VFP
register file is not preserved and restored at every context switch or taken
exception like the normal register file is, so some manual intervention is
required. Furthermore, special care is required for code that may sleep [i.e.,
may call schedule()], as NEON or VFP instructions will be executed in a
non-preemptible section for reasons outlined below.
//这里就说明了在内核运行的代码,内核在进行上下文切换时,不会主动保存和恢复浮点寄存器。

Interruptions in kernel mode

For reasons of performance and simplicity, it was decided that there shall be no
preserve/restore mechanism for the kernel mode NEON/VFP register contents. This
implies that interruptions of a kernel mode NEON section can only be allowed if
they are guaranteed not to touch the NEON/VFP registers. For this reason, the
following rules and restrictions apply in the kernel:
NEON/VFP code is not allowed in interrupt context;
NEON/VFP code is not allowed to sleep;
* NEON/VFP code is executed with preemption disabled.

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

这里提到在使用 kernel_neon_begin()/ kernel_neon_end()规则:

  1. NEON/VFP code 不允许在中断中使用
  2. NEON/VFP code 不允许睡眠
  3. NEON/VFP code 执行时是禁止抢占的
  • ARM架构内核使用浮点示例

    下面分别为三段计算代码,其执行的结果是相同的。
    ARM64 寄存器
    x0 - x30 是31个通用整形寄存器 , w0 ~ w30来访问这3164位寄存器的低32位,写入时会将高32位清零
    V0 - V31 浮点寄存器(向量寄存器),用于处理SIMD和浮点运算。长度不同称谓也不同,b,h,s,d,q,分别代表byte(8)half(16)single(32)double(64)quad(128)------------------
    int kernl_float_test_1(int test,int ratio){
        int result;
        result = test*2.6/ratio - test/20;
        return result;
    }
    ARM汇编:
        4084:       1e620280        scvtf   d0, w20 //将寄存器w20中的定点数转化为浮点数,存储在浮点寄存器d0中
        4088:       fd400101        ldr     d1, [x8] //浮点乘. dx为浮点寄存器,长度64(double)
        408c:       529999a8        mov     w8, #0xcccd                     // #52429
        4090:       72b99988        movk    w8, #0xcccc, lsl #16
        4094:       9ba87e88        umull   x8, w20, w8
        4098:       1e610800        fmul    d0, d0, d1 
        409c:       1e620301        scvtf   d1, w24
        40a0:       d364fd08        lsr     x8, x8, #36
        40a4:       1e611800        fdiv    d0, d0, d1  //浮点除
        40a8:       1e620101        scvtf   d1, w8
        40ac:       1e613800        fsub    d0, d0, d1
        40b0:       1e780014        fcvtzs  w20, d0    //将浮点数转化为定点数
    
  • -
    #include <asm/neon.h>
    int kernl_float_test_2(int test,int ratio){
    int result;
    if (!may_use_simd()) {
    //判断是否可以使用浮点,如果为判断在执行kernel_neon_begin可能会死机
    return;
    }
    kernel_neon_begin();
    result = test2.6/ratio - test/20;
    kernel_neon_end();
    return result;
    }

    Path:arch/arm64/kernel/fpsimd.c
    /

    • kernel_neon_begin(): obtain the CPU FPSIMD registers for use by the calling
    • context
    • Must not be called unless may_use_simd() returns true.
    • Task context in the FPSIMD registers is saved back to memory as necessary.
    • A matching call to kernel_neon_end() must be made before returning from the
    • calling context.
    • The caller may freely use the FPSIMD registers until kernel_neon_end() is
    • called.
      /
      void kernel_neon_begin(void)
      {
      if (WARN_ON(!system_supports_fpsimd()))
      return;
      BUG_ON(!may_use_simd());
      get_cpu_fpsimd_context();
      /
      Save unsaved fpsimd state, if any: /
      fpsimd_save();
      /
      Invalidate any task state remaining in the fpsimd regs: */
      fpsimd_flush_cpu_state();
      }
      EXPORT_SYMBOL(kernel_neon_begin);

      ARM汇编:
      4088: 94000000 bl 0 <kernel_neon_begin>
      408c: 90000008 adrp x8, 0 <>
      4090: 1e620280 scvtf d0, w20
      4094: fd400101 ldr d1, [x8]
      4098: 529999a8 mov w8, #0xcccd // #52429
      409c: 72b99988 movk w8, #0xcccc, lsl #16
      40a0: 9ba87e88 umull x8, w20, w8
      40a4: 1e610800 fmul d0, d0, d1
      40a8: 1e620301 scvtf d1, w24
      40ac: d364fd08 lsr x8, x8, #36
      40b0: 1e611800 fdiv d0, d0, d1
      40b4: 1e620101 scvtf d1, w8
      40b8: 1e613800 fsub d0, d0, d1
      40bc: 1e780014 fcvtzs w20, d0
      40c0: 94000000 bl 0 <kernel_neon_end>

    0000000000001580 <kernel_neon_begin>:
    1580: f81d0ff5 str x21, [sp,#-48]!
    ............................
    15d4: 37a00628 tbnz w8, #20, 1698 <kernel_neon_begin+0x118>
    15d8: b9404a68 ldr w8, [x19,#72]
    15dc: 90000014 adrp x20, 8 <fpsimd_save+0x8>

    0000000000000000 <fpsimd_save>:
    0: a9be4ff4 stp x20, x19, [sp,#-32]!
    4: a9017bfd stp x29, x30, [sp,#16]
    ..............
    68: 37b80088 tbnz w8, #23, 78 <fpsimd_save+0x78>
    6c: aa1303e0 mov x0, x19
    70: 94000000 bl 0 <fpsimd_save_state>

    0000000000000000 <fpsimd_save_state>: //这里就保存了浮点寄存器状态到X0
    0: ad000400 stp q0, q1, [x0]
    4: ad010c02 stp q2, q3, [x0,#32]
    8: ad021404 stp q4, q5, [x0,#64]
    c: ad031c06 stp q6, q7, [x0,#96]
    10: ad042408 stp q8, q9, [x0,#128]
    14: ad052c0a stp q10, q11, [x0,#160]
    18: ad06340c stp q12, q13, [x0,#192]
    1c: ad073c0e stp q14, q15, [x0,#224]
    20: ad084410 stp q16, q17, [x0,#256]
    24: ad094c12 stp q18, q19, [x0,#288]
    28: ad0a5414 stp q20, q21, [x0,#320]
    2c: ad0b5c16 stp q22, q23, [x0,#352]
    30: ad0c6418 stp q24, q25, [x0,#384]
    34: ad0d6c1a stp q26, q27, [x0,#416]
    38: ad0e741c stp q28, q29, [x0,#448]
    3c: ad8f7c1e stp q30, q31, [x0,#480]!
    40: d53b4428 mrs x8, fpsr
    44: b9002008 str w8, [x0,#32]
    48: d53b4408 mrs x8, fpcr
    4c: b9002408 str w8, [x0,#36]
    50: d65f03c0 ret

    -
    int kernl_float_test_3(int test,int ratio){
    int result;
    result = (test26)/(ratio10) - test/20;
    return result;
    }
    ARM汇编:
    4084: 529999a9 mov w9, #0xcccd // #52429
    4088: 72b99989 movk w9, #0xcccc, lsl #16
    408c: 1b087e88 mul w8, w20, w8
    4090: 0b180b0a add w10, w24, w24, lsl #2
    4094: 9ba97e89 umull x9, w20, w9
    4098: 531f794a lsl w10, w10, #1
    409c: 1aca0908 udiv w8, w8, w10
    40a0: d364fd29 lsr x9, x9, #36
    40a4: 4b090114 sub w20, w8, w9

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134

    上面三段计算代码,其结果是相同的,但是在用户空间和内核空间的执行产生效果可能不同,执行效率不同:

    1. kernl_float_test_1 在用户空间和内核空间都可以编译通过,在用户空间使用没有任何问题,但是在内核虽然可以编译通过,但使用时可能会破坏用户空间的浮点寄存器的状态
    2. kernl_float_test_2 内核使用浮点,必须按照这种方式使用,浮点计算安全,但是效率不高,可以看到汇编代码需要执行对浮点寄存器进行保存,相比较于保存恢复浮点寄存器状态开销,使用浮点运算有点不划算。
    3. kernl_float_test_3 内核和用户空间使用都没有问题,把浮点转化为整型计算,执行效率高于前两种
  • 在什么情况下适合启用内核Neon/VFP

    由前面可以了解到Neon是SIMD (Single Instruction Multiple Data) , 支持单指令多数据操作。也就是说不仅仅是浮点运算可以使用Neon,当你使用大量连续计算时,可以使用Neon对算法加速。其实内核中的加密算法基本都是了Neon加速,如sha1、sha2…sha512、aes、chacha20等。加密源码在 arch/arm64/crypto/

  • 在这里插入图片描述

    参考文章:

    ARM 浮点运算,软浮点,硬浮点

    ARM Cortex-A8: Whats the difference between VFP and NEON

    armel、armhf和arm64区别选择

    ARM64 汇编——寄存器和指令

    ARMv8-aarch64寄存器和指令集

    进程切换分析(1):基本框架

    linux kernel态下使用NEON对算法进行加速


本文链接: http://www.dtmao.cc/news_show_200201.shtml

附件下载

上一篇:ibtables 周作业

下一篇:复习 HTML基础

相关教程

    暂无相关的数据...

共有条评论 网友评论

验证码: 看不清楚?