【ARMv8 SIMD和浮点指令编程】NEON 加法指令——加法都能玩出花

news/2024/10/23 11:25:28/

向量加法包括常见的普通加指令，还包括长加、宽加、半加、饱和加、按对加、按对加并累加、选择高半部分结果加、全部元素加等。如果你和我一开始以为的只有一种普通加，那就太小看设计者了！同时这么多加法指令的确会提升我们设计程序的效率，同样学习这些指令也需要花费不少精力。

1 ADD

加（向量），该指令将两个源 SIMD&FP 寄存器中的相应元素相加，将结果放入向量中，并将向量写入目标 SIMD&FP 寄存器。

标量

在这里插入图片描述

ADD <V><d>, <V><n>, <V><m>

向量

在这里插入图片描述

ADD <Vd>.<T>, <Vn>.<T>, <Vm>.<T>

<V> 是宽度说明符，以“size”编码：

size<V>
0xRESERVED
10RESERVED
11D

<d> 是 SIMD&FP 目标寄存器的编号，在“Rd”字段中。

<n> 是第一个 SIMD&FP 源寄存器的编号，编码在“Rn”字段中。

<m> 是第二个 SIMD&FP 源寄存器的编号，编码在“Rm”字段中。

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<T> 是排列说明符，编码为“size:Q”：

sizeQ<T>
0008B
00116B
0104H
0118H
1002S
1014S
110RESERVED
1112D

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 ADD 指令的例子。

    auto *srcArr = new int[4];for (int i = 0; i < 4; i++) {srcArr[i] = 100 * (i + 1);}char *src = (char *) srcArr;LOGD("in srcArr: %d %d %d %d", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);asm volatile("LD1 {v0.4S}, [%[src]]\n""ADD v1.4S, v0.4S, v0.4S\n""ST1 {v1.4S}, [%[src]]\n":[src] "+r"(src):: "cc", "memory", "v0");LOGD("-----------------------------");LOGD("out srcArr: %d %d %d %d", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);delete[] srcArr;

ADD v1.4S, v0.4S, v0.4S 将 v0 寄存器 S 通道的值加上 v0 寄存器 S 通道的值的结果写入 v1 的 S 通道。

运行结果：

2023-05-20 14:58:44.906 5306-5306/com.example.myapplication D/native-armv8a: in srcArr: 100 200 300 400
2023-05-20 14:58:44.906 5306-5306/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-20 14:58:44.906 5306-5306/com.example.myapplication D/native-armv8a: out srcArr: 200 400 600 800

2 UADDL/UADDL2

无符号长加（向量），该指令将第一个源 SIMD&FP 寄存器的下半部分或上半部分中的每个向量元素与第二个源 SIMD&FP 寄存器的相应向量元素相加，将结果放入向量中，并将向量写入目标 SIMD&FP 寄存器。目标向量元素的长度是源向量元素的两倍。该指令中的所有值都是无符号整数值。

UADDL 指令从每个源寄存器的下半部分提取每个源向量。UADDL2 指令从每个源寄存器的上半部分提取每个源向量。

在这里插入图片描述

UADDL{2} <Vd>.<Ta>, <Vn>.<Tb>, <Vm>.<Tb>

2 是第二个和上半部分说明符。如果存在，它会导致对保存较窄元素的寄存器的高 64 位执行操作，并以“Q”编码：

Q2
0[absent]
1[present]

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，以“size”编码：

size<Ta>
008H
014S
102D
11RESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Tb> 是排列说明符，编码为“size:Q”：

sizeQ<T>
0008B
00116B
0104H
0118H
1002S
1014S
11xRESERVED

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 UADDL/UADDL2 指令的例子。

    auto *srcArr = new unsigned int[4];auto *outArr = new unsigned long long int[4]{0};for (int i = 0; i < 4; i++) {srcArr[i] = 100 * (i + 1);}char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);asm volatile("LD1 {v0.4S}, [%[src]]\n""UADDL v1.2D, v0.2S, v0.2S\n""UADDL2 v2.2D, v0.4S, v0.4S\n""ST1 {v1.2D, v2.2D}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1", "v2");LOGD("-----------------------------");LOGD("out outArr: %llu %llu %llu %llu", outArr[0], outArr[1], outArr[2], outArr[3]);delete[] srcArr;delete[] outArr;

UADDL v1.2D, v0.2S, v0.2S 将 v0 寄存器低半部分两个 S 通道的值加上 v0 寄存器低半部分两个 S 通道的值，并将结果写入 v1 寄存器的两个 D 通道。

UADDL2 v2.2D, v0.4S, v0.4S 将 v0 寄存器高半部分两个 S 通道的值加上 v0 寄存器高半部分两个 S 通道的值，并将结果写入 v2 寄存器的两个 D 通道。

运行结果：

2023-05-20 15:23:48.145 9806-9806/com.example.myapplication D/native-armv8a: in srcArr: 100 200 300 400
2023-05-20 15:23:48.145 9806-9806/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-20 15:23:48.145 9806-9806/com.example.myapplication D/native-armv8a: out outArr: 200 400 600 800

3 UADDW/UADDW2

无符号宽加，该指令将第一个源 SIMD&FP 寄存器的向量元素与第二个源 SIMD&FP 寄存器的下半部分或上半部分中相应的向量元素相加，将结果放入向量中，并将向量写入 SIMD&FP 目标寄存器。目标寄存器和第一个源寄存器的向量元素是第二个源寄存器的向量元素的两倍长。该指令中的所有值都是无符号整数值。

UADDW 指令从第二个源寄存器的下半部分提取向量元素。UADDW2 指令从第二个源寄存器的上半部分提取向量元素。

在这里插入图片描述

UADDW{2} <Vd>.<Ta>, <Vn>.<Ta>, <Vm>.<Tb>

2 是第二个和上半部分说明符。如果存在，它会导致对保存较窄元素的寄存器的高 64 位执行操作，并以“Q”编码：

Q2
0[absent]
1[present]

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，以“size”编码：

size<Ta>
008H
014S
102D
11RESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

<Tb> 是排列说明符，编码为“size:Q”：

sizeQ<T>
0008B
00116B
0104H
0118H
1002S
1014S
11xRESERVED

下面是使用 UADDW/UADDW2 指令的例子。

    auto *srcArr = new unsigned int[4];auto *outArr = new unsigned long long int[4]{0};for (int i = 0; i < 4; i++) {srcArr[i] = 100 * (i + 1);outArr[i] = 10 * (i + 1);}char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in outArr: %llu %llu %llu %llu", outArr[0], outArr[1], outArr[2], outArr[3]);asm volatile("LD1 {v0.4S}, [%[src]]\n""LD1 {v1.2D, v2.2D}, [%[dst]]\n""UADDW v3.2D, v1.2D, v0.2S\n""UADDW2 v4.2D, v2.2D, v0.4S\n""ST1 {v3.2D, v4.2D}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1", "v2", "v3", "v4");LOGD("-----------------------------");LOGD("out outArr: %llu %llu %llu %llu", outArr[0], outArr[1], outArr[2], outArr[3]);delete[] srcArr;delete[] outArr;

UADDW v3.2D, v1.2D, v0.2S 将 v0 寄存器低半部分两个 S 通道的值加上 v1 寄存器的两个 D 通道的值，并将结果写入 v3 寄存器的两个 D 通道。

UADDW2 v4.2D, v2.2D, v0.4S 将 v0 寄存器高半部分两个 S 通道的值加上 v2 寄存器的两个 D 通道的值，并将结果写入 v4 寄存器的两个 D 通道。

在这里插入图片描述

运行结果：

2023-05-20 15:56:42.446 1618-1618/com.example.myapplication D/native-armv8a: in srcArr: 100 200 300 400
2023-05-20 15:56:42.446 1618-1618/com.example.myapplication D/native-armv8a: in outArr: 10 20 30 40
2023-05-20 15:56:42.446 1618-1618/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-20 15:56:42.446 1618-1618/com.example.myapplication D/native-armv8a: out outArr: 110 220 330 440

4 UQADD

无符号饱和加法，该指令将两个源 SIMD&FP 寄存器的相应元素的值相加，将结果放入向量中，并将向量写入目标 SIMD&FP 寄存器。如果任何结果发生溢出，这些结果就会饱和。如果发生饱和，则设置累积饱和位 FPSR.QC。

标量

在这里插入图片描述

UQADD <V><d>, <V><n>, <V><m>

向量

在这里插入图片描述

UQADD <Vd>.<T>, <Vn>.<T>, <Vm>.<T>

<V> 是宽度说明符，以“size”编码：

size<V>
00B
01H
10S
11D

<d> 是 SIMD&FP 目标寄存器的编号，在“Rd”字段中。

<n> 是第一个 SIMD&FP 源寄存器的编号，编码在“Rn”字段中。

<m> 是第二个 SIMD&FP 源寄存器的编号，编码在“Rm”字段中。

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<T> 是排列说明符，编码为“size:Q”：

sizeQ<T>
0008B
00116B
0104H
0118H
1002S
1014S
110RESERVED
1112D

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 UQADD 指令的例子。

    auto *srcArr = new unsigned int[4];auto *outArr = new unsigned int[4];for (int i = 0; i < 4; i++) {srcArr[i] = 0xFFFFFFFF;outArr[i] = i;}char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in outArr: %u %u %u %u", outArr[0], outArr[1], outArr[2], outArr[3]);asm volatile("LD1 {v0.4S}, [%[src]]\n""LD1 {v1.4S}, [%[dst]]\n""UQADD v2.4S, v0.4S, v1.4S\n""ST1 {v2.4S}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1", "v2");LOGD("-----------------------------");LOGD("out outArr: %u %u %u %u", outArr[0], outArr[1], outArr[2], outArr[3]);delete[] srcArr;delete[] outArr;

运行过程中加入断点可查到 FPSR.QC 已经被置为 1（从低到高第 27 位（低位从 0 开始））。

在这里插入图片描述

运行结果：

2023-05-20 16:57:15.332 8522-8522/com.example.myapplication D/native-armv8a: in srcArr: 4294967295 4294967295 4294967295 4294967295
2023-05-20 16:57:15.332 8522-8522/com.example.myapplication D/native-armv8a: in outArr: 0 1 2 3
2023-05-20 16:57:15.332 8522-8522/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-20 16:57:15.332 8522-8522/com.example.myapplication D/native-armv8a: out outArr: 4294967295 4294967295 4294967295 4294967295

5 ADDHN/ADDHN2

Add returning High Narrow，该指令将第一个源 SIMD&FP 寄存器中的每个向量元素加上第二个源 SIMD&FP 寄存器中的相应向量元素，将结果的最高有效一半放入向量中，并将向量写入目标 SIMD&FP 寄存器的下半部分或上半部分。结果被截断，有关四舍五入的结果，可使用 RADDHN、RADDHN2。

ADDHN 指令将向量写入目标寄存器的下半部分并清除上半部分，而 ADDHN2 指令将向量写入目标寄存器的上半部分而不影响寄存器的其它位。

在这里插入图片描述

ADDHN{2} <Vd>.<Tb>, <Vn>.<Ta>, <Vm>.<Ta>

2 是第二个和上半部分说明符。如果存在，它会导致对保存较窄元素的寄存器的高 64 位执行操作，并以“Q”编码：

Q2
0[absent]
1[present]

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，以“size”编码：

size<Ta>
008H
014S
102D
11RESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

<Tb> 是排列说明符，编码为“size:Q”：

sizeQ<T>
0008B
00116B
0104H
0118H
1002S
1014S
11xRESERVED

下面是使用 ADDHN/ADDHN2 指令的例子。

    auto *srcArr = new unsigned long long int[4];auto *outArr = new unsigned int[4]{0};for (int i = 0; i < 4; i++) {srcArr[i] = 0x10010000000 * (i + 1);}char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: 0x%llx 0x%llx 0x%llx 0x%llx", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);asm volatile("LD1 {v0.2D, v1.2D}, [%[src]]\n""ADDHN v2.2S, v0.2D, v0.2D\n""ADDHN2 v2.4S, v1.2D, v1.2D\n""ST1 {v2.4S}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1", "v2");LOGD("-----------------------------");LOGD("out outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);delete[] srcArr;delete[] outArr;

ADDHN v2.2S, v0.2D, v0.2D 将 v0 的两个 D 通道的值加上 v0 的两个 D 通道的值，接着取结果的高位（也就是 D 通道的高 S 通道部分）写入 v2 的两个低 S 通道，v2 寄存器高 S 通道全部清零。

ADDHN2 v2.4S, v1.2D, v1.2D 将 v1 的两个 D 通道的值加上 v1 的两个 D 通道的值，接着取结果的高位（也就是 D 通道的高 S 通道部分）写入 v2 的两个高 S 通道，并保持 v2 其它位不变。

在这里插入图片描述

运行结果：

2023-05-21 11:16:56.576 6664-6664/com.example.myapplication D/native-armv8a: in srcArr: 0x10010000000 0x20020000000 0x30030000000 0x40040000000
2023-05-21 11:16:56.576 6664-6664/com.example.myapplication D/native-armv8a: in outArr: 0x0 0x0 0x0 0x0
2023-05-21 11:16:56.576 6664-6664/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-21 11:16:56.576 6664-6664/com.example.myapplication D/native-armv8a: out outArr: 0x200 0x400 0x600 0x800

6 RADDHN/RADDHN2

和 ADDHN/ADDHN2 的唯一区别在于对结果进行了四舍五入，而非截断。

下面是使用 RADDHN/RADDHN2 指令的例子。使用 ADDHN/ADDHN2 的例子将命令替换为 RADDHN/RADDHN2 即可。

    auto *srcArr = new unsigned long long int[4];auto *outArr = new unsigned int[4]{0};for (int i = 0; i < 4; i++) {srcArr[i] = 0x10010000000 * (i + 1);}char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: 0x%llx 0x%llx 0x%llx 0x%llx", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);asm volatile("LD1 {v0.2D, v1.2D}, [%[src]]\n""RADDHN v2.2S, v0.2D, v0.2D\n""RADDHN2 v2.4S, v1.2D, v1.2D\n""ST1 {v2.4S}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1", "v2");LOGD("-----------------------------");LOGD("out outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);delete[] srcArr;delete[] outArr;

从运行结果来看，最后出现了 0x801 这个值，这是因为 0x40040000000 + 0x40040000000 = 0x80080000000，提取高 4 个字节的时候同时四舍五入进位了。

运行结果：

2023-05-21 11:11:08.096 20999-20999/com.example.myapplication D/native-armv8a: in srcArr: 0x10010000000 0x20020000000 0x30030000000 0x40040000000
2023-05-21 11:11:08.096 20999-20999/com.example.myapplication D/native-armv8a: in outArr: 0x0 0x0 0x0 0x0
2023-05-21 11:11:08.096 20999-20999/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-21 11:11:08.096 20999-20999/com.example.myapplication D/native-armv8a: out outArr: 0x200 0x400 0x600 0x801

7 UHADD

无符号半加，该指令将两个源 SIMD&FP 寄存器中相应的无符号整数值相加，将每个结果右移一位，将结果放入向量中，并将向量写入目标 SIMD&FP 寄存器。结果被截断。有关四舍五入的结果，请使用 URHADD。

在这里插入图片描述

UHADD <Vd>.<T>, <Vn>.<T>, <Vm>.<T>

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<T> 是排列说明符，编码在“size:Q”字段中。它可以具有以下值：

sizeQ<T>
0008B
00116B
0104H
0118H
1002S
1014S
11xRESERVED

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 UHADD 指令的例子。

    auto *srcArr = new unsigned int[4];auto *outArr = new unsigned int[4];for (int i = 0; i < 4; i++) {srcArr[i] = 0x01020304 * (i + 1);outArr[i] = 0x10203040 * (i + 1);}char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: 0x%x 0x%x 0x%x 0x%x", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);asm volatile("LD1 {v0.4S}, [%[src]]\n""LD1 {v1.4S}, [%[dst]]\n""UHADD v2.4S, v0.4S, v1.4S\n""ST1 {v2.4S}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1", "v2");LOGD("-----------------------------");LOGD("out outArr: 0x%x 0x%x 0x%x 0x%x", outArr[0], outArr[1], outArr[2], outArr[3]);delete[] srcArr;delete[] outArr;

我们计算一组数值：0x1020304 + 0x10203040 = 0x11223344 = 0b00010001 00100010 00110011 01000100，右移一位后即 0b00001000 10010001 00011001 10100010 = 0x089119A2。

运行结果：

2023-05-21 14:59:44.900 13393-13393/com.example.myapplication D/native-armv8a: in srcArr: 0x1020304 0x2040608 0x306090c 0x4080c10
2023-05-21 14:59:44.900 13393-13393/com.example.myapplication D/native-armv8a: in outArr: 0x10203040 0x20406080 0x306090c0 0x4080c100
2023-05-21 14:59:44.900 13393-13393/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-21 14:59:44.900 13393-13393/com.example.myapplication D/native-armv8a: out outArr: 0x89119a2 0x11223344 0x19b34ce6 0x22446688

8 URHADD

和 UHADD 的唯一区别在于对结果进行了四舍五入，而非截断。

笔者实际没有琢磨出设计这条指令的意义，就比如说 S 通道相加，最大的无符号数是 0xFFFFFFFF，如果 0xFFFFFFFF + 0xFFFFFFFF，也就是两倍的 0xFFFFFFFF，对这个结果右移 1 位（相当于除以 2），还是 0xFFFFFFFF，根本就无法触及四舍五入的操作！

9 ADDP

标量

加一对元素，该指令将源 SIMD&FP 寄存器中的两个向量元素相加，并将结果写入目标 SIMD&FP 寄存器。

在这里插入图片描述

ADDP <V><d>, <Vn>.<T>

<V> 是宽度说明符，以“size”编码：

size<V>
0xRESERVED
10RESERVED
11D

<d> 是 SIMD&FP 目标寄存器的编号，在“Rd”字段中。

<Vn> 是 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<T> 是排列说明符，编码为“size”：

size<V>
0xRESERVED
10RESERVED
11D

向量

该指令通过将第一个源 SIMD&FP 寄存器的向量元素连接在第二个源 SIMD&FP 寄存器的向量元素之后创建一个向量，从连接的向量中读取每对相邻的向量元素，将每对值加在一起，将结果放入 向量，并将向量写入目标 SIMD&FP 寄存器。

在这里插入图片描述

ADDP <Vd>.<T>, <Vn>.<T>, <Vm>.<T>

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<T> 是排列说明符，编码为“size:Q”：

sizeQ<T>
0008B
00116B
0104H
0118H
1002S
1014S
110RESERVED
1112D

<Vn> 是第一个 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Vm> 是第二个 SIMD&FP 源寄存器的名称，在“Rm”字段中编码。

下面是使用 ADDP 指令的例子。

    auto *srcArr = new unsigned int[4];auto *outArr = new unsigned int[4];for (int i = 0; i < 4; i++) {srcArr[i] = i + 1;outArr[i] = (i + 1) * 2;}char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in outArr: %u %u %u %u", outArr[0], outArr[1], outArr[2], outArr[3]);asm volatile("LD1 {v0.4S}, [%[src]]\n""LD1 {v1.4S}, [%[dst]]\n""ADDP v2.4S, v0.4S, v1.4S\n""ST1 {v2.4S}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1", "v2");LOGD("-----------------------------");LOGD("out outArr: %u %u %u %u", outArr[0], outArr[1], outArr[2], outArr[3]);delete[] srcArr;delete[] outArr;

ADDP v2.4S, v0.4S, v1.4S 将 v1 寄存器的 S 通道连接到 v0 寄存器之后形成一个新的向量，从这个新的向量中按对加，最后将结果写入 v2 的 S 通道。

运行结果：

2023-05-21 16:16:33.270 11613-11613/com.example.myapplication D/native-armv8a: in srcArr: 1 2 3 4
2023-05-21 16:16:33.270 11613-11613/com.example.myapplication D/native-armv8a: in outArr: 2 4 6 8
2023-05-21 16:16:33.270 11613-11613/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-21 16:16:33.270 11613-11613/com.example.myapplication D/native-armv8a: out outArr: 3 7 6 14

10 UADDLP

Unsigned Add Long Pairwise，该指令将源 SIMD&FP 寄存器中向量中的相邻无符号整数值对相加，将结果放入向量中，并将向量写入目标 SIMD&FP 寄存器。目标向量元素的长度是源向量元素的两倍。

在这里插入图片描述

UADDLP <Vd>.<Ta>, <Vn>.<Tb>

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，编码在“size:Q”字段中。 它可以具有以下值：

sizeQ<Ta>
0004H
0018H
0102S
0114S
1001D
1012D
11xRESERVED

<Vn> 是 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Tb> 是排列说明符，编码在“size:Q”字段中。 它可以具有以下值：

sizeQ<Tb>
0008B
00116B
0104H
0118H
1002S
1014S
11xRESERVED

下面是使用 UADDLP 指令的例子。

    auto *srcArr = new unsigned int[4];auto *outArr = new unsigned long long int[2]{0};for (int i = 0; i < 4; i++) {srcArr[i] = i + 1;}char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in outArr: %llu %llu", outArr[0], outArr[1]);asm volatile("LD1 {v0.4S}, [%[src]]\n""UADDLP v1.2D, v0.4S\n""ST1 {v1.2D}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1");LOGD("-----------------------------");LOGD("out outArr: %llu %llu", outArr[0], outArr[1]);delete[] srcArr;delete[] outArr;

UADDLP v1.2D, v0.4S 将 v0 寄存器的 S 通道按对加，最后将结果写入 v1 的两个 D 通道。

运行结果：

2023-05-21 16:34:07.706 1951-1951/com.example.myapplication D/native-armv8a: in srcArr: 1 2 3 4
2023-05-21 16:34:07.706 1951-1951/com.example.myapplication D/native-armv8a: in outArr: 0 0
2023-05-21 16:34:07.706 1951-1951/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-21 16:34:07.706 1951-1951/com.example.myapplication D/native-armv8a: out outArr: 3 7

11 UADALP

Unsigned Add and Accumulate Long Pairwise，该指令将源 SIMD&FP 寄存器中向量中的相邻无符号整数值对相加，并将结果与目标 SIMD&FP 寄存器的向量元素累加。目标向量元素的长度是源向量元素的两倍。

在这里插入图片描述

UADALP <Vd>.<Ta>, <Vn>.<Tb>

<Vd> 是 SIMD&FP 目标寄存器的名称，在“Rd”字段中编码。

<Ta> 是排列说明符，编码在“size:Q”字段中。 它可以具有以下值：

sizeQ<Ta>
0004H
0018H
0102S
0114S
1001D
1012D
11xRESERVED

<Vn> 是 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<Tb> 是排列说明符，编码在“size:Q”字段中。 它可以具有以下值：

sizeQ<Tb>
0008B
00116B
0104H
0118H
1002S
1014S
11xRESERVED

下面是使用 UADALP 指令的例子。

    auto *srcArr = new unsigned int[4];auto *outArr = new unsigned long long int[2]{0};for (int i = 0; i < 4; i++) {srcArr[i] = i + 1;}outArr[0] = 1;outArr[1] = 2;char *src = (char *) srcArr;char *dst = (char *) outArr;LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in outArr: %llu %llu", outArr[0], outArr[1]);asm volatile("LD1 {v0.4S}, [%[src]]\n""LD1 {v1.2D}, [%[dst]]\n""UADALP v1.2D, v0.4S\n""ST1 {v1.2D}, [%[dst]]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1");LOGD("-----------------------------");LOGD("out outArr: %llu %llu", outArr[0], outArr[1]);delete[] srcArr;delete[] outArr;

UADALP v1.2D, v0.4S 将 v0 寄存器的 S 通道按对加，得到按对加的结果后，将其分别累加到 v1 的两个 D 通道。

运行结果：

2023-05-21 16:45:00.687 4754-4754/com.example.myapplication D/native-armv8a: in srcArr: 1 2 3 4
2023-05-21 16:45:00.687 4754-4754/com.example.myapplication D/native-armv8a: in outArr: 1 2
2023-05-21 16:45:00.687 4754-4754/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-21 16:45:00.687 4754-4754/com.example.myapplication D/native-armv8a: out outArr: 4 9

12 ADDV

Add across Vector，该指令将源 SIMD&FP 寄存器中的每个向量元素相加，并将标量结果写入目标 SIMD&FP 寄存器。

在这里插入图片描述

ADDV <V><d>, <Vn>.<T>

<V> 是目标宽度说明符，在“size”字段中编码。它可以具有以下值：

Vsize
B00
H01
S10
RESERVED11

<d> 是 SIMD&FP 目标寄存器的编号，在“Rd”字段中编码。

<Vn> 是 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<T> 是排列说明符，编码在“size:Q”字段中。 它可以具有以下值：

sizeQT
0008B
00116B
0104H
0118H
100RESERVED
1014S
11xRESERVED

下面是使用 ADDV 指令的例子。

    auto *srcArr = new unsigned int[4];unsigned int dst = 0;for (int i = 0; i < 4; i++) {srcArr[i] = i + 1;}char *src = (char *) srcArr;LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in dst: %u", dst);asm volatile("LD1 {v0.4S}, [%[src]]\n""ADDV S1, v0.4S\n""MOV %w[dst], v1.S[0]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1");LOGD("-----------------------------");LOGD("out dst: %u", dst);delete[] srcArr;

ADDV S1, v0.4S 将 v0 寄存器的 S 通道值全部相加，并将得到的结果写入 S1 寄存器。

运行结果：

2023-05-21 16:59:39.237 18281-18281/com.example.myapplication D/native-armv8a: in srcArr: 1 2 3 4
2023-05-21 16:59:39.237 18281-18281/com.example.myapplication D/native-armv8a: in dst: 0
2023-05-21 16:59:39.237 18281-18281/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-21 16:59:39.237 18281-18281/com.example.myapplication D/native-armv8a: out dst: 10

13 UADDLV

Unsigned sum Long across Vector，该指令将源 SIMD&FP 寄存器中的每个向量元素相加，并将标量结果写入目标 SIMD&FP 寄存器。目标标量是源向量元素的两倍长。该指令中的所有值都是无符号整数值。

在这里插入图片描述

UADDLV <V><d>, <Vn>.<T>

<V> 是目标宽度说明符，在“size”字段中编码。它可以具有以下值：

Vsize
H00
S01
D10
RESERVED11

<d> 是 SIMD&FP 目标寄存器的编号，在“Rd”字段中编码。

<Vn> 是 SIMD&FP 源寄存器的名称，在“Rn”字段中编码。

<T> 是排列说明符，编码在“size:Q”字段中。 它可以具有以下值：

sizeQT
0008B
00116B
0104H
0118H
100RESERVED
1014S
11xRESERVED

下面是使用 UADDLV 指令的例子。

    auto *srcArr = new unsigned int[4];unsigned long long int dst = 0;for (int i = 0; i < 4; i++) {srcArr[i] = i + 1;}char *src = (char *) srcArr;LOGD("in srcArr: %u %u %u %u", srcArr[0], srcArr[1], srcArr[2], srcArr[3]);LOGD("in dst: %llu", dst);asm volatile("LD1 {v0.4S}, [%[src]]\n""UADDLV D1, v0.4S\n""MOV %[dst], v1.D[0]\n":[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory", "v0", "v1");LOGD("-----------------------------");LOGD("out dst: %llu", dst);delete[] srcArr;

UADDLV D1, v0.4S 将 v0 寄存器的 S 通道值全部相加，并将得到的结果写入 D1 寄存器。

运行结果：

2023-05-21 17:06:17.782 6272-6272/com.example.myapplication D/native-armv8a: in srcArr: 1 2 3 4
2023-05-21 17:06:17.782 6272-6272/com.example.myapplication D/native-armv8a: in dst: 0
2023-05-21 17:06:17.782 6272-6272/com.example.myapplication D/native-armv8a: -----------------------------
2023-05-21 17:06:17.782 6272-6272/com.example.myapplication D/native-armv8a: out dst: 10

14 其它

上面很多加法指令都是基于无符号数的，实际上它们也有对应的有符号数版本，就不再一一展开了。

参考资料

1.《ARMv8-A-Programmer-Guide》
2.《Arm® A64 Instruction Set Architecture Armv8, for Armv8-A architecture profile》


http://www.ppmy.cn/news/180979.html

相关文章

惠普580服务器硬盘,HP(惠普)DL580G7服务器配置及详细描述.xlsx

惠普580服务器硬盘,HP(惠普)DL580G7服务器配置及详细描述.xlsx

文档介绍&#xff1a; 产品型号序列号描述数量单价 Server HP DL580G7 E7520 2P 16GB Svr 595241 - AA1 标配 2个 Intel 4核 Xeon E7520 处理器(1.86GHz, 18MB 缓存, 95W) , 可扩至四路处理器, Intel7500 芯片组; 集成 iLO3 远程管理, 标配 16GB(4x4GB) DIMMs (DDR3 PC3 - 1060…
阅读更多...
centos6.7环境之kvm虚拟化quem工具配置及使用详解

centos6.7环境之kvm虚拟化quem工具配置及使用详解

环境准备 需要勾选CPU的虚拟化支持&#xff0c;支持cpu虚拟化的CPU列表&#xff1a; intel支持虚拟化技术CPU列表&#xff1a; Intel 6 Cores / 12 Threads CPU Number&#xff1a;Code Name&#xff1a;Nehalem-EX Xeon E6540 Xeon E7530 Xeon E7540 Xeon L7545Code Name&…
阅读更多...
戴尔7050mt支持win7系统

戴尔7050mt支持win7系统

修改bios方法&#xff1a; 1、secure boot找到secure boot enable 设置为disabled。 2、右下角“apply&#xff08;应用&#xff09;”——确认。 3、Ceneral找到Advanced Boot Options 将Enable Legacy Option ROMs 前面的勾打上&#xff1a;点击右下角“apply&#xff08;应用…
阅读更多...
在Windows Server 2022系统上安装 Brother MFC-7450打印机驱动

在Windows Server 2022系统上安装 Brother MFC-7450打印机驱动

Windows Server 2022系统&#xff0c;接上Brother MFC-7450 打印机&#xff0c;能识别出来&#xff0c;但是提示驱动程序无法使用&#xff08;请忽视打印机图标灰色状态&#xff0c;因为是在打印机关机的状态下截图的。&#xff09; 从打印机官网可以看到驱动最高支持到win10X6…
阅读更多...
e系列是服务器CPU吗,Intel-至强E系列CPU参数

e系列是服务器CPU吗,Intel-至强E系列CPU参数

《Intel-至强E系列CPU参数》由会员分享，可在线阅读，更多相关《Intel-至强E系列CPU参数(6页珍藏版)》请在人人文库网上搜索。 1、Intel Xeon E系列服务器处理器一、 Intel Xeon E 系列 CPU 命名规则首先， Intel E3，E5，E7 代表了 3 个不同档次的至强CPU，这种命名方式类似桌…
阅读更多...
24核48线虚拟化服务器,24核48线程的威力：戴尔PowerEdge R910服务器评测

24核48线虚拟化服务器,24核48线程的威力：戴尔PowerEdge R910服务器评测

在“整体设计的提升：初品戴尔PowerEdge R910服务器”一文中，我们通过完整的拆解过程及图片向大家详细介绍了PowerEdge R910这款全功能Intel Xeon 7500平台服务器的硬件结构，4颗英特尔至强E7540 6核CPU(最多支持8核)、24个物理核心和48线程让我们对它的性能充满了期待。本文我…
阅读更多...
NXP LS1046A及飞腾新四核 FT2004 PCIE EP端LINUX设备驱动开发

NXP LS1046A及飞腾新四核 FT2004 PCIE EP端LINUX设备驱动开发

文章目录 前言一、PCIE 硬件简介二、PCIE EP地址映射原理介绍1. PCI总线的各种域&#xff08;存储器域、PCI总线域&#xff09;2. 开发EP设备驱动要做的事 三、NXP LS1046A PCIE EP端驱动1. LS1046A处理器简介2. 开发环境介绍3. 驱动源码介绍3.1. 源码概览3.2. EP测试程序 pci-…
阅读更多...
1504_AURIX_TC275参考手册_芯片介绍

1504_AURIX_TC275参考手册_芯片介绍

全部学习汇总&#xff1a; GreyZhang/g_TC275: happy hacking for TC275! (github.com) 逐渐开始了解MCU的功能了&#xff0c;我发现RM手册躲不过去了。与其见招拆招&#xff0c;倒不如先大概看一遍好让自己对这个芯片有一个初步的了解。这样&#xff0c;从头开始简略看一下参考…
阅读更多...
最新文章

Copyright @ 2022~2023