ARM SIMD 指令集：NEON 简介

最新推荐文章于 2024-06-02 16:45:47 发布
最新推荐文章于 2024-06-02 16:45:47 发布
阅读量46 收藏
点赞数
文章标签： arm开发
原文链接：https://manzp.blog.csdn.net/article/details/114686930
版权

ARM SIMD 指令集：NEON 简介

一、NEON 简介

1.1、NEON 简介
  • SIMD，即 single instruction multiple data，单指令流多数据流，也就是说一次运算指令可以执行多个数据流，从而提高程序的运算速度，实质是通过 数据并行 来提高执行效率
  • ARM NEON 是 ARM 平台下的 SIMD 指令集，利用好这些指令可以使程序获得很大的速度提升。不过对很多人来说，直接利用汇编指令优化代码难度较大，这时就可以利用 ARM NEON intrinsic 指令，它是底层汇编指令的封装，不需要用户考虑底层寄存器的分配，但同时又可以达到原始汇编指令的性能。
    • NEON 是一种 128 位的 SIMD 扩展指令集，由 ARMv7 引入，在 ARMv8 对其功能进行了扩展（支持向量化运算），支持包括加法、乘法、比较、移位、绝对值 、极大极小极值运算、保存和加载指令等运算
    • ARM 架构下的下一代 SIMD 指令集为 SVE（Scalable Vector Extension，可扩展矢量指令），支持可变矢量长度编程，SVE 指令集的矢量寄存器的长度最小支持 128 位，最大可以支持 2048 位，以 128 位为增量
  • ARM NEON 技术的核心是 NEON 单元，主要由四个模块组成：NEON 寄存器文件、整型执行流水线、单精度浮点执行流水线和数据加载存储和重排流水线
  • ARM 基本数据类型有三种：字节（Byte，8bit）、半字（Halfword，16bit）、字（Word，32bit）
  • 新的 Armv8a 架构有 32 个 128bit 向量寄存器，老的 ArmV7a 架构有 32 个 64bit（可当作 16 个128bit）向量寄存器，被用来存放向量数据，每个向量元素的类型必须相同，根据处理元素的大小可以划分为 2/4/8/16 个通道

在这里插入图片描述

1.2、NEON 使用方式
  • ARM 平台提供了四种使用 NEON 技术的方式，分别为 NEON 内嵌函数(intrinsics)、NEON 汇编、NEON 开源库和编译器自动向量化
    • NEON 内嵌函数：类似于普通函数调用，简单易维护，编译器负责将 NEON 指令替换成汇编语言的复杂任务，主要包括寄存器分配和代码调度以及指令集重排，来达到获取最高性能的目标
    • NEON 汇编：汇编语言相对晦涩难懂，移植较难、不便于维护，但其 效率最高
    • NEON 开源库：如 Ne10、OpenMAX、ffmpeg、Eigen3 和 Math-neon 等
    • 编译器自动向量化：目前大多数编译器都具有自动向量化的功能，将 C/C++ 代码自动替换为 SIMD 指令。从编译技术上来说，自动向量化一般包含两部分：循环向量化（Loop vectorization）和超字并行向量化（SLP，Superword-Level Parallelism vectorization，又称 Basic block vectorization）
      • 循环向量化：将循环进行展开，增加循环中的执行代码来减少循环次数
      • SLP 向量化：编译器将多个标量运算绑定到一起，使其成为向量运算
  • 编写代码时要加上头文件：#include <arm_neon.h>，编译时要加上相应的 编译选项：LOCAL_CFLAGS += -mcpu=cortex-a53 -mfloat-abi=softfp -mfpu=neon-vfpv4 -O3
1.3、编译器自动向量化的编译选项
  • 目前支持自动向量化的编译器有 Arm Compiler 6、Arm C/C++ Compiler、LLVM-clang 以及 GCC，这几种编译器间的相互关系如下表所示：
    在这里插入图片描述
1.3.1 Arm Compiler 中使能自动向量化

  • 下文中 Arm Compiler 6 与 Arm C/C++ Compiler 使用 armclang 统称，armclang 使能自动向量化配置信息如下表所示：
    在这里插入图片描述

  • armclang 实现自动向量化示例：

# AArch32
armclang --target=arm-none-eabi -mcpu=cortex-a53 -O1 -fvectorize main.c

# AArch64，O2 及以上优化等级默认启用自动向量化 -fvectorize
armclang –target=aarch64-arm-none-eabi -O2 main.c

  • 1
  • 2
  • 3
  • 4
  • 5
1.3.2 LLVM-clang 中使能自动向量化
  • Android NDK 从 r13 开始以 clang 为默认编译器，使用 Android NDK 工具链使能自动向量化配置参数如下表所示：
    在这里插入图片描述
  • 在 CMake 中配置自动向量化方式如下：
# method 1
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O1 -fvectorize")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O1 -fvectorize")

# method 2
set(CMAKE_C_FLAGS “KaTeX parse error: Double subscript at position 9: {CMAKE_C_̲FLAGS}</span> -…{CMAKE_CXX_FLAGS} -O2”)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
1.3.3 GCC 中使能自动向量化
  • 在 gcc 中使能自动向量化配置参数如下：

在这里插入图片描述

  • 在不明确配置 -mcpu 的情况下，编译器将使用默认配置（取决于编译工具链时的选项设置）进行编译，通常情况下 -mfpu 和 -mcpu 的配置存在关联性，对应关系如下:
    在这里插入图片描述

  • gcc 中实现自动向量化的编译配置如下：

# AArch32
arm-none-linux-gnueabihf-gcc -mcpu=cortex-a53 -mfpu=neon -ftree-vectorize -O2 main.c

# AArch64
aarch64-none-linux-gnu-gcc -mcpu=cortex-a53 -ftree-vectorize -O2 main.c

  • 1
  • 2
  • 3
  • 4
  • 5
1.4、NEON intrisics 指令在x86平台的仿真
# 1、编程时加上头文件
#include "NEON_2_SSE.h"

# 2、编译时加上如下编译选项（debug）
# gdb 调试时出现value optimized out 解决方法如下:
# 由于 gcc 在编译过程中默认使用 -O2 优化选项，希望进行单步跟踪调试时，应使用 -O0 选项
set(CMAKE_C_FLAGS “-w -mfma -mavx512f -msse4 -msse4.1 -msse4.2 -O0”)
set(CMAKE_CXX_FLAGS “-w -mfma -mavx512f -msse4 -msse4.1 -msse4.2 -O0”)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

二、NEON 数据类型和指令类型

2.1、NEON 数据类型
  • NEON 向量数据类型是根据以下模式命名的：<type><size>x<number_of_lanes>_t，eg：int8x16_t 是一个16 通道 的向量，每个通道包含一个有符号 8 位整数
  • NEON 还提供了数组向量数据类型，命名模式如下：<type><size>x<number of lanes>x<length of array>_t，eg：int8x16x4_t 是一个长度为 4 的数组，每一个数据的类型为 int8x16_t
 struct int8x16x4_t 
 {
   int8x16_t val[4];   // 数组元素的长度范围 2 ~ 4
 };
  • 1
  • 2
  • 3
  • 4
  • 5

在这里插入图片描述

  • 下表列出了 16 个 D 寄存器上的向量数据类型及 16 个 Q 寄存器上的向量数据类型
  • D 寄存器一次能处理 8 个 u8 数据，Q 寄存器一次能处理 16 个 u8 数据
D寄存器（64-bit）Q寄存器（128-bit）
int8x8_tint8x16_t
int16x4_tint16x8_t
int32x2_tint32x4_t
int64x1_tint64x2_t
uint8x8_tuint8x16_t
uint16x4_tuint16x8_t
uint32x2_tuint32x4_t
uint64x1_tuint64x2_t
float16x4_tfloat16x8_t
float32x2_tfloat32x4_t
poly8x8_tpoly8x16_t
poly16x4_tpoly16x8_t
2.2、NEON 指令类型

NEON指令的函数名组成格式：v<mod><opname><shape><flags>_<type> ，逐元素进行操作

  • v：vector 的缩写，表示向量
  • mod：
    • q：表示饱和计算，int8x8_t vqadd_s8(int8x8_t a, int8x8_t b); // a 加 b 的结果做饱和计算
    • h：表示折半计算，int8x8_t vhsub_s8(int8x8_t a, int8x8_t b); // a 减 b 的结果右移一位
    • d：表示加倍计算，int32x4_t vqdmull_s16(int16x4_t a, int16x4_t b); // a 乘 b 的结果扩大一倍, 最后做饱和操作
    • r：表示舍入计算，int8x8_t vrhadd_s8(int8x8_t a, int8x8_t b); // 将 a 与 b 的和减半,同时做 rounding 操作, 每个通道可以表达为: (ai + bi + 1) >> 1
    • p：表示 pairwise 计算，int8x8_t vpadd_s8(int8x8_t a, int8x8_t b); // 将 a, b 向量的相邻数据进行两两和操作
  • opname：表示具体操作，比如 add，sub 等
  • shape：
    • l：表示 long，输出向量的元素长度是输入长度的 2 倍，uint16x8_t vaddl_u8(uint8x8_t a, uint8x8_t b);
    • w：表示 wide，第一个输入向量和输出向量类型一样，且是第二个输入向量元素长度的 2 倍，uint16x8_t vsubw_u8(uint16x8_t a, uint8x8_t b);
    • n：表示 narrow，输出向量的元素长度是输入长度的 1/2 倍，uint32x2_t vmovn_u64(uint64x2_t a);
    • _high：AArch64专用，而且和 l/n 配合使用，当使用 l(Long) 时，表示输入向量只有高 64bit 有效；当使用 n(Narrow) 时，表示输出只有高 64bit 有效，int16x8_t vsubl_high_s8(int8x16_t a, int8x16_t b); // a 和 b 只有高 64bit 参与运算
    • _n：表示有标量参与向量计算，int8x8_t vshr_n_s8(int8x8_t a, const int n); // 向量 a 中的每个元素右移 n 位
    • _lane： 指定向量中某个通道参与向量计算，int16x4_t vmul_lane_s16(int16x4_t a, int16x4_t v, const int lane); // 取向量 v 中下标为 lane 的元素与向量 a 做乘法计算
  • flags：q 表示 quad word，四字，指定函数对 128 位 Q 寄存器进行操作，不带 q 则对 64 位 D 寄存器进行操作
  • type：表示函数的参数类型（u8/16/32/64、s8/16/32/64、f16/32 等）
  • 正常指令：
    • 生成大小相同且类型通常与操作数向量相同的结果向量，结果大于 
               2 
        
       
         n 
        
       
      
     
       2^n 
      
     
   </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.6644em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.6644em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span></span></span></span></span> 的除以 <span class="katex--inline"><span class="katex"><span class="katex-mathml"> 
    
     
      
       
       
         2 
        
       
         n 
        
       
      
     
       2^n 
      
     
   </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.6644em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.6644em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span></span></span></span></span> 取余数，结果小于 0 的加上 <span class="katex--inline"><span class="katex"><span class="katex-mathml"> 
    
     
      
       
       
         2 
        
       
         n 
        
       
      
     
       2^n 
      
     
   </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.6644em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.6644em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span></span></span></span></span></li><li>eg： <code>int8x8_t vadd_s8 (int8x8_t __a, int8x8_t __b)</code></li></ul> </li><li><strong>饱和指令：</strong>
  • 当超过数据类型指定的范围则自动限制在该范围内（结果大于 
             2 
        
       
         n 
        
       
      
        − 
       
      
        1 
       
      
     
       2^n - 1 
      
     
   </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.7477em; vertical-align: -0.0833em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.6644em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right: 0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right: 0.2222em;"></span></span><span class="base"><span class="strut" style="height: 0.6444em;"></span><span class="mord">1</span></span></span></span></span> 的截断到 <span class="katex--inline"><span class="katex"><span class="katex-mathml"> 
    
     
      
       
       
         2 
        
       
         n 
        
       
      
        − 
       
      
        1 
       
      
     
       2^n - 1 
      
     
   </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.7477em; vertical-align: -0.0833em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.6644em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right: 0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right: 0.2222em;"></span></span><span class="base"><span class="strut" style="height: 0.6444em;"></span><span class="mord">1</span></span></span></span></span> ，结果小于 0 的截断到 0 ），函数中用 <code>q</code> 来标记（在 <code>v</code> 之后）</li><li>eg： <code>int8x8_t vqsub_s8 (int8x8_t __a, int8x8_t __b)</code></li></ul> </li><li><strong>长指令：</strong>
  • 对双字向量操作数执行运算，生成四字向量的结果，所生成的元素一般是操作数元素宽度的两倍，并属于同一类型，函数中用 l 来标记，结果大于 
             2 
        
       
         n 
        
       
      
     
       2^n 
      
     
   </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.6644em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.6644em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span></span></span></span></span> 的减去 <span class="katex--inline"><span class="katex"><span class="katex-mathml"> 
    
     
      
       
       
         2 
        
       
         n 
        
       
      
     
       2^n 
      
     
   </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.6644em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.6644em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span></span></span></span></span> （一般不会），结果小于 0 的加上 <span class="katex--inline"><span class="katex"><span class="katex-mathml"> 
    
     
      
       
       
         2 
        
       
         n 
        
       
      
     
       2^n 
      
     
   </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.6644em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height: 0.6644em;"><span class="" style="top: -3.063em; margin-right: 0.05em;"><span class="pstrut" style="height: 2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span></span></span></span></span> （可能出现）</li><li>eg：<code>int16x8_t vaddl_s8 (int8x8_t __a, int8x8_t __b)</code></li></ul> </li><li><strong>宽指令：</strong>
  • 一个双字向量操作数和一个四字向量操作数执行运算，生成四字向量结果。所生成的元素和第一个操作数的元素是第二个操作数元素宽度的两倍，函数中用 w 来标记
  • eg：int16x8_t vaddw_s8 (int16x8_t __a, int8x8_t __b)
  • 窄指令：
    • 四字向量操作数执行运算，并生成双字向量结果，所生成的元素一般是操作数元素宽度的一半，函数中用 hn 来标记
    • eg： int8x8_t vaddhn_s16 (int16x8_t __a, int16x8_t __b)

  • 三、NEON 指令简介

    • NEON 指令执行流程如下：
      在这里插入图片描述
    // 用 float 类型的 val 值，去初始化寄存器，值为 val 
float32x4_t vec = vdupq_n_f32(val);

 
 
    
 
 
    • 1
    • 2
    3.1、数据读取指令（内存数据加载到寄存器）

    在这里插入图片描述

    • 顺序读取
    // vld1 -> loads a vector from memory
float32x2_t temp = vld1_f32(const float32_t * __a);  // load 2 float32  64-bit
float32x4_t temp = vld1q_f32(const float32_t * __a); // load 4 float32 128-bit

 
 
    
 
 
    • 1
    • 2
    • 3
    • 交织读取
    // vld2 -> loads 2 vector from memory，vld3 vld4 the same as vld2
// 交叉存放: a1 a2 a3 a4 -> temp.val[0]:a1 a3 ; temp.val[1]:a2 a4 
float32x2x2_t temp = vld2_f32 (const float32_t * __a);  // load 4 float32 64-bit
float32x4x2_t temp = vld2q_f32 (const float32_t * __a); // load 8 float32 128-bit

 
 
    
 
 
    • 1
    • 2
    • 3
    • 4

    在这里插入图片描述

    3.2、数据存储指令（寄存器数据回写到内存 ）
    • 顺序存储
    // vst1 -> stores a vector into memory
void vst1_f32 (float32_t * ptr, float32x2_t temp);  // store 2 float32  64-bit
void vst1q_f32 (float32_t * ptr, float32x4_t temp); // store 4 float32  64-bit

 
 
    
 
 
    • 1
    • 2
    • 3
    • 交织存储
    // vst2 -> stores 2 vector into memory，It interleaves the 2 vectors into memory.
void vst2_f32 (float32_t * ptr, float32x2x2_t temp);  // store 4 float32  64-bit
void vst2q_f32 (float32_t * ptr, float32x4x2_t temp); // store 8 float32  64-bit

 
 
    
 
 
    • 1
    • 2
    • 3

    在这里插入图片描述

    3.3、数据处理指令
    3.3.1 获取寄存器的值
    // 从寄存器中访问具体元素：extract a single lane (element) from a vector
uint8_t vgetq_lane_u8(uint8x16_t vec, __constrange(0,15) int lane); 

 
 
    
 
 
    • 1
    • 2
    3.3.2 设置寄存器的值
    // 设置寄存器具体元素值：set a single lane (element) within a vector.
// 注意：返回值要用参数中的 vec 寄存器来接收
uint16x8_t vsetq_lane_u16(uint16_t value, uint16x8_t vec, __constrange(0,7) int lane);
eg: vec = vsetq_lane_u16(111, vec, 5);

    // 设置寄存器所有元素的值（以某一个通道的值）：Set all lanes to the value of one lane of a vector
    uint8x8_t vdup_lane_u8(uint8x8_t vec, __constrange(0,7) int lane)
    eg: vec = vdup_lane_u8(vec, 5); // 所有元素都设置成第五通道的值

    // 设置寄存器所有元素的值（以某一个固定的值）
    uint8x16_t vmovq_n_u8(uint8_t value);
    eg: uint8x16_t vec = vmovq_n_u8(5); // 所有元素都设置成 5

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    3.3.3 加减乘除运算
    • 加法
    // 正常指令加法运算
int32x2_t vadd_s32(int32x2_t __a, int32x2_t __b);

    // 饱和指令加法，结果超出元素类型的最大值时，元素就取最大值；小于元素类型的最小值时，元素就取最小值
    int32x2_t vqadd_s32(int32x2_t __a, int32x2_t __b);

    // 长指令加法运算，为了防止溢出，输出向量长度是输入的两倍
    int64x2_t vaddl_s32(int32x2_t __a, int32x2_t __b);

    // 向量半加：相加结果再除 2(向下取整)，ri = (ai + bi) >> 1：
    int32x2_t vhadd_s32(int32x2_t __a, int32x2_t __b);

    // 向量舍入半加：相加结果再除 2，ri = (ai + bi + 1) >> 1：
    int32x2_t vrhadd_s32(int32x2_t __a, int32x2_t __b);

    // pairwise add，r0 = a0 + a1, …,r3 = a6 + a7, r4 = b0 + b1, …,r7 = b6 + b7
    int8x8_t vpadd_s8(int8x8_t __a, int8x8_t __b);

    // long pairwise add， r0 = a0 + a1, …, r3 = a6 + a7
    int16x4_t vpaddl_s8(int8x8_t __a);

    // Long pairwise add and accumulate，r0 = a0 + (b0 + b1), …, r3 = a3 + (b6 + b7)
    int16x4_t vpadal_s8(int16x4_t __a, int8x8_t __b);

    // 宽指令加法运算，第一个输入向量的长度是第二个输入向量长度的两倍
    int64x2_t vaddw_s32(int64x2_t __a, int32x2_t __b);

    // 窄指令加法，结果的类型大小是输入类型大小的一半，待验证？？？
    int16x4_t vaddhn_s32(int32x4_t __a, int32x4_t __b);

    • 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

    在这里插入图片描述

    • 减法
    // 正常减法运算
int32x4_t vsubq_s32(int32x4_t __a, int32x4_t __b);

    // 饱和指令减法，结果超出元素类型的最大值时，元素就取最大值
    int32x2_t vqsub_s32 (int32x2_t __a, int32x2_t __b);

    // 长指令减法运算，为了防止溢出
    int64x2_t vsubl_s32(int32x2_t __a, int32x2_t __b);

    // 向量半减：相减结果再除 2，ri = (ai - bi) >> 1
    int32x2_t vhsub_s32 (int32x2_t __a, int32x2_t __b)；

    // 宽指令减法运算，第一个元素宽度大于第二个
    int64x2_t vsubw_s32(int64x2_t __a, int32x2_t __b);

    // 窄指令减法，结果的类型大小是输入类型大小的一半
    int16x4_t vsubhn_s32 (int32x4_t __a, int32x4_t __b);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    在这里插入图片描述

    • 乘法
    // ri = ai * bi，正常指令，逐元素相乘
int32x2_t vmul_s32 (int32x2_t __a, int32x2_t __b);

    // ri = ai * bi, 长指令, 为了防止溢出
    int64x2_t vmull_s32 (int32x2_t __a, int32x2_t __b)

    // ri = ai * b，有标量参与向量运算
    int32x2_t vmul_n_s32 (int32x2_t __a, int32_t __b);

    // ri = ai * b, 长指令, 为了防止溢出
    int64x2_t vmull_n_s32 (int32x2_t __a, int32_t __b);

    // ri = ai * b[c]
    int32x2_t vmul_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c)；

    // ri = ai * b[c], 长指令,为了防止溢出
    int64x2_t vmull_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c);

    // ri = sat(ai * bi) 饱和指令，当结果溢出时，取饱和值
    int32x2_t vqdmulh_s32 (int32x2_t __a, int32x2_t __b);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 乘加
    // ri = ai + bi * ci，正常指令
int32x2_t vmla_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c)

    // ri = ai + bi * ci，长指令
    int64x2_t vmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);

    // ri = ai + bi * c，正常指令，乘以标量
    int32x2_t vmla_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c);

    // ri = ai + bi * c，长指令，乘以标量
    int64x2_t vmlal_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c);

    // ri = ai + bi * c[d]
    int32x2_t vmla_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);

    // ri = ai + bi * c[d] 长指令
    int64x2_t vmlal_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);

    // ri = ai + bi * ci 在加法之前，bi、ci相乘的结果不会被四舍五入
    float32x2_t vfma_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)

    // ri = sat(ai + bi * c)
    int64x2_t vqdmlal_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c);

    // ri = sat(ai + bi * c[d])
    int64x2_t vqdmlal_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);

    • 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
    • 乘减
    // ri = ai - bi * ci
int32x2_t vmls_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c);

    // ri = ai - bi * ci 长指令，正常指令
    int64x2_t vmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);

    // ri = ai - bi * c，正常指令，乘以标量
    int32x2_t vmls_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c);

    // ri = ai - bi * c，长指令，乘以标量
    int64x2_t vmlsl_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c);

    // ri = ai - bi * c[d]
    int32x2_t vmls_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);

    // ri = ai - bi * c[d] 长指令
    int64x2_t vmlsl_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);

    // ri = ai - bi * ci 在减法之前，bi、ci相乘的结果不会被四舍五入
    float32x2_t vfms_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c);

    // ri = sat(ai - bi * c）
    int64x2_t vqdmlsl_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c);

    // ri = sat(ai - bi * c[d]）
    int64x2_t vqdmlsl_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);

    • 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
    • 倒数/平方根
      在这里插入图片描述
    // finds an approximate reciprocal of each element in a vector
float32x2_t vrecpe_f32 (float32x2_t __a);
// 注：vrecpe_type 计算倒数能保证千分之一左右的精度，如 1.0 的倒数为 0.998047
// 执行完如下语句后能提高百万分之一精度
// float32x4_t recip = vrecpeq_f32(src); 此时能达到千分之一左右的精度，如 1.0 的倒数为 0.998047
// recip = vmulq_f32 (vrecpsq_f32 (src, rec), rec); 执行后能达到百万分之一左右的精度，如1.0的倒数为0.999996
// recip = vmulq_f32 (vrecpsq_f32 (src, rec), rec); 再次执行后能基本能达到完全精度，如1.0的倒数为1.000000

    // performs a Newton-Raphson step for finding the reciprocal
    float32x2_t vrecps_f32 (float32x2_t a, float32x2_t b);
    float32x4_t vrecpsq_f32(float32x4_t a, float32x4_t b);

    // 近似平方根
    float32x2_t vrsqrts_f32(float32x2_t a, float32x2_t b);
    float32x4_t vrsqrtsq_f32(float32x4_t a, float32x4_t b);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 取负
    // vneg -> ri = -ai
int32x2_t vneg_s32 (int32x2_t __a);

 
 
    
 
 
    • 1
    • 2
    3.3.4 逻辑运算
    • 取整
    /*--1、to nearest, ties to even--*/  
float32x2_t vrndn_f32 (float32x2_t __a);

    /–2、to nearest, ties away from zero–/
    float32x2_t vrnda_f32 (float32x2_t __a);

    /–3、towards +Inf–/
    float32x2_t vrndp_f32 (float32x2_t __a);

    /–4、towards -Inf–/
    float32x2_t vrndm_f32 (float32x2_t __a);

    /–5、towards 0–/
    float32x2_t vrnd_f32 (float32x2_t __a);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 比较运算：注意返回类型为无符号整数类型
      在这里插入图片描述
    // 逻辑比较操作，结果为 true，则该元素的所有 bit 位被设置为 1；结果为 false，则该元素的所有 bit 位被设置为 0
// 注意返回类型为无符号整数类型

    // compares equal : vceq -> ri = ai == bi ? 1…1 : 0…0
    uint32x2_t vceq_s32 (int32x2_t __a, int32x2_t __b);

    // compares greater-than or equal : vcge-> ri = ai >= bi ? 1…1:0…0
    uint32x2_t vcge_s32 (int32x2_t __a, int32x2_t __b);

    // compares less-than or equal : vcle -> ri = ai <= bi ? 1…1:0…0
    uint32x2_t vcle_s32 (int32x2_t __a, int32x2_t __b);

    // compares greater-than : vcgt -> ri = ai > bi ? 1…1:0…0
    uint32x2_t vcgt_s32 (int32x2_t __a, int32x2_t __b);

    // compares less-than : vclt -> ri = ai < bi ? 1…1:0…0
    uint32x2_t vclt_s32 (int32x2_t __a, int32x2_t __b);

    // 向量的绝对值比较
    // compares absolute greater-than or equal : vcage -> ri = |ai| >= |bi| ? 1…1:0…0;
    uint32x2_t vcage_f32 (float32x2_t __a, float32x2_t __b);

    // compares absolute less-than or equal : vcale -> ri = |ai| <= |bi| ? 1…1:0…0;
    uint32x2_t vcale_f32 (float32x2_t __a, float32x2_t __b);

    // compares absolute greater-than : vcage -> ri = |ai| > |bi| ? 1…1:0…0;
    uint32x2_t vcagt_f32 (float32x2_t __a, float32x2_t __b);

    // compares absolute less-than : vcalt -> ri = |ai| < |bi| ? 1…1:0…0;
    uint32x2_t vcalt_f32 (float32x2_t __a, float32x2_t __b);

    // 向量与不等于零判断
    // vtst -> ri = (ai & bi != 0) ? 1…1:0…0;
    uint32x2_t vtst_s32 (int32x2_t __a, int32x2_t __b);

    • 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
    • 绝对值
    // Absolute : vabs -> ri = |ai|
int32x2_t vabs_s32 (int32x2_t __a);

    // Absolute difference : vabd -> ri = |ai - bi|
    int32x2_t vabd_s32 (int32x2_t __a, int32x2_t __b);

    // Absolute difference and accumulate: vaba -> ri = ai + |bi - ci|
    int32x2_t vaba_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 最大最小值
    // vmax -> ri = ai >= bi ? ai : bi; 取向量元素中较大的那一个输出
int32x2_t vmax_s32 (int32x2_t __a, int32x2_t __b);

    // vmin -> ri = ai >= bi ? bi : ai;
    int32x2_t vmin_s32 (int32x2_t __a, int32x2_t __b);

    // compares adjacent pairs of elements, 获取相邻对的最大值
    // vpmax -> vpmax r0 = a0 >= a1 ? a0 : a1, …, r4 = b0 >= b1 ? b0 : b1, …;
    int32x2_t vpmax_s32 (int32x2_t __a, int32x2_t __b);

    // compares adjacent pairs of elements, 获取相邻对的最小值
    // vpmin -> r0 = a0 >= a1 ? a1 : a0, …, r4 = b0 >= b1 ? b1 : b0, …;
    int32x2_t vpmin_s32 (int32x2_t __a, int32x2_t __b);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 移位运算：第二个参数是 int 型，参数均为 vector 的时候可为负数
    // Vector shift left: vshl -> ri = ai << bi，如果 bi 是负数，则变成右移
// The bits shifted out of each element are lost
uint16x8_t vshlq_u16 (uint16x8_t __a, int16x8_t __b);   // 正常指令
uint16x8_t vrshlq_u16 (uint16x8_t __a, int16x8_t __b);  // 正常指令结果 + 四舍五入
uint16x8_t vqshlq_u16 (uint16x8_t __a, int16x8_t __b);  // 饱和指令截断到 (0，65535)
uint16x8_t vqrshlq_u16 (uint16x8_t __a, int16x8_t __b); // 饱和指令截断到 (0，65535) + 四舍五入

    // Vector shift left by constant: vshlq -> ri = ai << b，如果 b 是负数，则变成右移
    // The bits shifted out of the left of each element are lost
    uint16x8_t vshlq_n_u16(uint16x8_t a, __constrange(0,15) int b); // 正常指令
    uint16x8_t vqshlq_n_u16(uint16x8_t a, __constrange(0,15) int b); // 饱和指令截断到 (0，65535), ri = sat(ai << b);

    // Vector signed->unsigned rounding narrowing saturating shift right by constant
    uint8x8_t vqrshrun_n_s16 (int16x8_t __a, const int __b); // 移位后舍入

    // Vector shift right：可以通过左移传入负数来实现

    // Vector shift left by constant: vshrq -> ri = ai >> b
    uint16x8_t vshrq_n_u16(uint16x8_t a, __constrange(1,16) int b);
    uint16x8_t vrshrq_n_u16(uint16x8_t a, __constrange(1,16) int b);
    // 右移累加，vsra -> ri = (ai >> c) + (bi >> c);
    uint16x8_t vsraq_n_u16(uint16x8_t a, uint16x8_t b, __constrange(1,16) int c);
    uint16x8_t vrsraq_n_u16(uint16x8_t a, uint16x8_t b, __constrange(1,16) int c);

    /–Vector shift left and insert: vsli ->; The least significant bit in each element
    in the destination vector is unchanged. left shifts each element in the second input
    vector by an immediate value, and inserts the results in the destination vector.
    It does not affect the lowest n significant bits of the elements in the destination
    register. Bits shifted out of the left of each element are lost. The first input vector
    holds the elements of the destination vector before the operation is performed.–    /
    uint16x8_t vsliq_n_u16 (uint16x8_t __a, uint16x8_t __b, const int __c);

    /–Vector shift right and insert: vsri -> ; The two most significant bits in the
    destination vector are unchanged. right shifts each element in the second input vector
    by an immediate value, and inserts the results in the destination vector. It does not
    affect the highest n significant bits of the elements in the destination register.
    Bits shifted out of the right of each element are lost.The first input vector holds
    the elements of the destination vector before the operation is performed.–    /
    uint16x8_t vsriq_n_u16 (uint16x8_t __a, uint16x8_t __b, const int __c);

    • 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
    • 按位运算
    // vmvn -> ri = ~ai
int32x2_t vmvn_s32 (int32x2_t __a);

    // vand -> ri = ai & bi
    int32x2_t vand_s32 (int32x2_t __a, int32x2_t __b);

    // vorr -> ri = ai | bi
    int32x2_t vorr_s32 (int32x2_t __a, int32x2_t __b);

    // veor -> ri = ai ^ bi
    int32x2_t veor_s32 (int32x2_t __a, int32x2_t __b);

    // vbic -> ri = ~ai & bi
    int32x2_t vbic_s32 (int32x2_t __a, int32x2_t __b);

    // vorn -> ri = ai | (~bi)
    int32x2_t vorn_s32 (int32x2_t __a, int32x2_t __b);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    3.3.5 数据类型转换
    // 浮点转定点 
// 在 f32 转到 u32 时，是向下取整，且如果是负数，则转换后为 0
uint32x4_t vcvtq_u32_f32(float32x4_t a); 
uint32x4_t vcvtq_n_u32_f32(float32x4_t a, __constrange(1,32) int b);

    // 定点转浮点
    float32x4_t vcvtq_f32_u32(uint32x4_t a);
    float32x4_t vcvtq_n_f32_u32(uint32x4_t a, __constrange(1,32) int b);

    // 浮点之间转换
    float16x4_t vcvt_f16_f32(float32x4_t a); // VCVT.F16.F32 d0, q0
    float32x4_t vcvt_f32_f16(float16x4_t a);

    // 定点之间转换
    int16x8_t vmovl_s8 (int8x8_t a);
    int8x8_t vqmovn_s16 (int16x8_t a);
    int32x4_t vmovl_s16 (int16x4_t a);
    int16x4_t vqmovn_s32 (int32x4_t a);

    // 向量重新解释类型转换运算：将元素类型为 type2 的 vector 转换为元素类型为 type1 的 vector
    // 将向量视为另一类型而不更改其值
    float32x2_t vreinterpret_f32_u32 (uint32x2_t __a);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    3.3.6 寄存器数据重排
    • 按索引重排
    // vext -> 提取第二个 vector 的低端的 c 个元素和第一个 vector 的高端的剩下的几个元素
// 如：src1 = {1,2,3,4,5,6,7,8}
   //   src2 = {9,10,11,12,13,14,15,16}
   //   dst = vext_s8(src1,src2,3)时，则dst = {4,5,6,7,8, 9,10,11}
int8x8_t vext_s8 (int8x8_t __a, int8x8_t __b, const int __c);

    // vtbl1 -> 第二个vector是索引，根据索引去第一个vector（相当于数组）中搜索相应的元素
    // 并输出新的vector，超过范围的索引返回的是 0
    // 如：src1 = {1,2,3,4,5,6,7,8}
    // src2 = {0,0,1,1,2,2,7,8}
    // dst = vtbl1_u8(src1,src2)时，则dst = {1,1,2,2,3,3,8,0}
    int8x8_t vtbl1_s8 (int8x8_t __a, int8x8_t __b);

    // vtbl2 -> 数组长度扩大到2个vector
    // 如：src.val[0] = {1,2,3,4,5,6,7,8}
    // src.val[1] = {9,10,11,12,13,14,15,16}
    // src2 = {0,0,1,1,2,2,8,10}
    // dst = vtbl2_u8(src,src2)时，则 dst = {1,1,2,2,3,3,9,11}
    int8x8_t vtbl2_s8 (int8x8x2_t __a, int8x8_t __b);
    //vtbl3 vtbl4类似

    // vtbx1 -> 与vtbl1功能一样，不过搜索到的元素是用来替换第一个vector中的元素，
    // 并输出替换后的新vector，当索引超出范围时，则不替换第一个vector中相应的元素。
    int8x8_t vtbx1_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c);
    // vtbx2 vtbx3 vtbx4类似

    // vbsl -> Bitwise Select, 按位选择，参数为(mask, src1, src2)
    // mask 的某个 bit 为1，则选择 src1 中对应的 bit，为 0，则选择 src2 中对应的 bit
    int8x8_t vbsl_s8 (uint8x8_t __a, int8x8_t __b, int8x8_t __c);

    • 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
    • 反转向量元素
    // vrev -> 将vector中的元素位置反转
// 如：src1 = {1,2,3,4,5,6,7,8}
//    dst = vrev64_s8(src1)时，则dst = {8,7,6,5,4,3,2,1}
int8x8_t vrev64_s8 (int8x8_t __a);

    // 如：src1 = {1,2,3,4,5,6,7,8}
    // dst = vrev32_s8(src1)时，则dst = {4,3,2,1,8,7,6,5}
    int8x8_t vrev32_s8 (int8x8_t __a);

    // 如：src1 = {1,2,3,4,5,6,7,8}
    // dst = vrev16_s8(src1)时，则dst = {2,1,4,3,6,5,8,7}
    int8x8_t vrev16_s8 (int8x8_t __a);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 转置
    // vtrn -> 将两个输入 vector 的元素通过转置生成一个有两个 vector 的矩阵
// 如：src.val[0] = {1,2,3,4,5,6,7,8}
//    src.val[1] = {9,10,11,12,13,14,15,16}
//    dst = vtrn_u8(src.val[0], src.val[1])时，
//    则 dst.val[0] = {1,9, 3,11,5,13,7,15}
//       dst.val[1] = {2,10,4,12,6,14,8,16}
int8x8x2_t vtrn_s8 (int8x8_t __a, int8x8_t __b);

 
 
    
 
 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 交叉
    // vzip_type: 将两个输入 vector 的元素通过交叉生成一个有两个vector的矩阵
// 如：src.val[0] = {1,2,3,4,5,6,7,8}
//     src.val[1] = {9,10,11,12,13,14,15,16}
//     dst = vzip_u8(src.val[0], src.val[1])时，
//     则dst.val[0] = {1,9, 2,10,3,11,4,12}
//       dst.val[1] = {5,13,6,14,7,15,8,16}
int8x8x2_t vzip_s8 (int8x8_t __a, int8x8_t __b); 

 
 
    
 
 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 反交叉
    // vuzp_type: 将两个输入vector的元素通过反交叉生成一个有两个vector的矩阵（通过这个可实现n-way 交织）
// 如：src.val[0] = {1,2,3,4,5,6,7,8}
//    src.val[1] = {9,10,11,12,13,14,15,16}
//    dst = vuzp_u8(src.val[0], src.val[1])时，
//    则dst.val[0] = {1,3,5,7,9, 11,13,15}
//      dst.val[1] = {2,4,6,8,10,12,14,16}
int8x8x2_t vuzp_s8 (int8x8_t __a, int8x8_t __b);

 
 
    
 
 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 组合向量：将两个 64 位向量组合为单个 128 位向量
    // vcombine -> 将两个元素类型相同的输入 vector 拼接成一个同类型但大小是输入vector两倍的新vector。
uint8x16_t   vcombine_u8(uint8x8_t low, uint8x8_t high);

 
 
    
 
 
    • 1
    • 2
    • 拆分向量：将一个 128 位向量拆分为 2 个 64 位向量
    // 从寄存器中获取低半部分元素
uint8x8_t vget_low_u8(uint8x16_t a);

    // 从寄存器中获取高半部分元素
    uint8x8_t vget_high_u8(uint8x16_t a);

    • 1
    • 2
    • 3
    • 4
    • 5

    四、NEON 进阶

    五、参考连接

    1、Neon Intrinsics各函数介绍(*****)
    2、https://developer.arm.com/documentation（*****）
    3、ARM Neon Intrinsics 学习指北：从入门、进阶到学个通透（*****）
    4、ARM NEON 技术之 NEON 基础介绍（***）
    5、移动端算法优化（******）
    6、利用 ARM NEON intrinsic 优化常用数学运算（***）

ting160126
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【ARMv8 SIMD和浮点指令编程】NEON 移动指令——精通 MOV？
洪伟的专栏
06-18 813
移动指令主要涉及 MOV 和 MVN，它们分别是移动和求反移动。如果你认为仅仅两条指令，还是太小看设计者了！
【ARMv8 SIMD和浮点指令编程】编程基础
洪伟的专栏
02-14 1191
ARM 高级 SIMD 架构、相关的实现和支持软件通常被称为 NEON 技术。AArch32（相当于 ARMv7 的 NEON 指令）和 AArch64 都有 NEON 指令集。两者都可以显著加速在大型数据集上的重复操作。这在媒体编解码器等应用中很有用。AArch64 的 NEON 架构使用 32 × 128 位寄存器，是 ARMv7 的两倍。这些寄存器与浮点指令使用的寄存器相同。
ARM SIMD NEON 简介 (翻译自 Introducing NEON Development Article)
AngelLover2017的博客
04-23 3045
目录NEON简介SIMD是什么?ARM SIMD 指令集NEON是什么？NEON架构概览支持的数据类型NEON寄存器NEON指令NEON开发汇编器Intrinsics NEON简介 这篇文章介绍了ARM NEON技术，这项技术首次实现是在ARM Cortex-A8 处理器上。这篇文章将讲述通用的SIMD概念以及NEON架构，并给出如何利用此技术的概要描述，包含以下章节： SIMD是什么？ NEON是什么？ NEON的架构概览 NEON开发技术 SIMD是什么? 一些现代软件，尤其是多媒体编解码软件和图形
【genius_platform软件平台开发】第八十二讲：ARM Neon指令集一（ARM NEON Intrinsics, SIMD运算, 优化心得）
随意的风的专栏
11-16 1382
由于Neon实现往往跟循环展开等技巧一起使用，代码往往比较长。可以先阅读普通实现的代码实现了解顶层逻辑，再阅读Neon实现的代码。例如，我们希望学习全连接层（innerproduct）的Neon实现，其普通实现的位置在ncnn/src/layer/innerproduct.cpp，对应的Neon加速实现的位置在ncnn/src/layer/arm/innerproduct_arm.cpp。2. 进阶：注意细节处理，学习常用算子的实现。4. 其他：相关的研讨会视频、库、文档等。3. 学个通透：了解原理。
【SIMD】NEON-intrinsic指令集总结
weixin_43730667的博客
07-12 1013
SIMD是使用一条指令同时处理多个数据的计算技术，可以理解为将原先的一次计算一个值改为一次并行计算多个值。这种并行技术是通过将多个数据打包传输至某一向量寄存器,用CPU核心中多个ALU一次计算处理该个向量寄存器来实现的。
[①ARM Neon]: Neon Intrinsic简介
Eng_ingLi的博客
09-28 315
ARM Neon指令集简介
【CPU】ARM底层汇编之neon指令集优化（附实例）
Yngz_Miao的博客
12-16 1万+
当在ARM芯片上进行一些例如图像处理等计算的时候，常常会因为计算量太大造成计算帧率较低的情况。因而，需要选择一种更加简单快捷的计算方式以获得处理速度上的提升。ARM NEON就是一个不错的选择。 Neon指令优化 NEON是一种SIMD(Single Instruction Multiple Data)指令，也就是说，NEON可以把若干源(source)操作数(operand)打包放到一个源寄存器...
ARM指令集--简介
MHD0815的博客
03-16 392
ARM指令集是专为ARM架构处理器设计的一系列机器指令集合。ARM（Advanced RISC Machines）以其精简指令集计算机（RISC）设计理念为基础，提供了高效、低功耗的指令系统。ARM指令集历经多个版本迭代，目前最新的主流版本包括ARMv8-A（支持AArch64和AArch32两种执行状态）。
ARM NEON指令集总结
热门推荐
JabamiYu的博客
07-11 1万+
ARM的NEON是类似于X86的SSE2的一种优化的指令集，主要就是为了实现SIMD全称Single Instruction Multiple Data，单指令多数据流，能够复制多个操作数，并把它们打包在大型寄存器的一组指令集。简单来说就是处理一些算法的时候，可以并行处理，大大提高了效率。 在Android手机上大部分都是ARM架构的，我们开启NEON后就可以使用这些指令集了，当然可以使用汇编，...
基于C++的图像处理算法实现、INTEL上SSE加速、ARM上NEON加速
04-18
图像处理算法实现、INTEL上SSE加速、ARM上NEON加速 1.常用图像处理算子实现 2.常用图像处理算子基于Arm 指令集Neon的实现 3.常用图像处理算子基于intel 指令集SSE的实现
simde:SIMD指令集的实现适用于本机不支持它们的系统
03-06
仅SIMDe标头库可在本身不支持它们的硬件上提供快速，可移植的实现，例如在ARM上调用函数。 如果硬件支持本机实现，则不会降低性能（例如，SSE / 在上全速运行，在上是等）。 这使通过一些关键方式将代码移植到其他...
neon programmers guide
12-23
ARM官方发布的NEON指令集（SIMD）开发指南。 This book introduces NEON technology as it is used on ARM Cortex ™ -A series processors that implement the ARMv7–A or ARMv7–R architectures profiles. It ...
高性能计算实验报告CPU/GPU SIMD
07-05
常见的 SIMD 指令集包括 Intel 的 MMX、SSE 和 AVX，以及 ARM 的 NEON。 GPU SIMD GPU（图形处理器）也有 SIMD 功能，但是其实现方式和 CPU 略有不同。GPU 由许多小的处理单元组成，每个处理单元可以执行相同的指令...
单片机与DSP中的ARM发布新的媒体和信号处理NEON技术
11-25
　NEON技术是64/128位单指令多数据流（SIMD）指令集，用于新一代媒体和信号处理应用加速。NEON技术下执行MP3音频解码器，CPU频率可低于10兆赫；运行GSM AMR语音数字编解码器，CPU频率仅为13兆赫。新技术包含指令集、...
BUUCTF--[V&N2020 公开赛]warmup
A13837377363的博客
05-30 144
在不指定rsi的情况，open会直接将rsi里面的值作为flag值，而rsi里面有时候存着地址，是一个极大值，可能会引起一些意想不到的问题。例如这题中，执行rop的时候rsi存着的是buf的地址，是一个极大值，一开始我没有pop rsi为0，导致执行了好几遍都没法orw成功，加上了pop rsi 0才成功读出flag。有沙盒，分析了一下，write的count不等于0x10就可以，0x30什么的都可以。怎么办呢，细心的小伙伴会发现我们知道libc的基址，那可以写在libc的bss上面啊。
ARM IHI0069F GIC architecture specification (7)
铁匠的七寸宫
05-27 932
GICv3组件
【ARMv7-A】——CP15 协处理器
最新发布
tyustli
06-02 267
这种机制有些类似于 ARM 中的寄存器，当处于不同的处理器模式时某些 ARM 寄存器可能有不同的物理寄存器，比如 SPSR 寄存器，每一种处理器模式下都对应一个独立的物理寄存器（用户模式和系统模式对应同样的物理寄存器，这是一个例外）MRC：将协处理器的寄存器中的数值传送到ARM处理器的寄存器中、如果协处理器不能成功地执行该操作，将产生未定义的指令异常中断(例如在 USER 模式下操作协处理器)。下面的指令将协处理器 CP15 的寄存器 C0 寄存器的数据传送到 ARM 寄存器 R0 中。
Harmony os Next——Retrofit网络库的使用和封装
FranzLiszt的博客
06-02 366
Retrofit作为Android平台最为常用的一个第三方网络库，搭配Kotlin的协程，使用极为便捷。通过Harmony的工作人员的努力，制作出的Retrofit For Harmony Library依旧十分强大。
simd指令集c++
07-28
3. NEON：是ARM架构下的SIMD指令集，用于移动设备和嵌入式系统。在C++中，可以使用<em>arm_neon.h头文件中的函数和数据类型来编写NEON代码。 4. OpenCL：是一种跨平台的并行计算框架，可以利用各种硬件（包括CPU、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值