SIMD

v{1.q}{2.r}{3.d}{13.p}{11.h} \
XXX \
{17.n|m|p|a|i|x}{16.u|s}{4.l}{5.w}{12.hn}{6.q}{14.nm}{15.v}{7.b|s|h|d}_{8.lane{q}}_{9.high}_{10.n}_type

• 1.q saturating
• 2.r rounding
• 3.d doubling
• 4.l widen
• 5.w 只 widen 一个输入参数
• 6.q long (128-bit)
• 7.b 参数都是 scalar: int8,int16,int32,int64
• 8.lane, 使用 v[lane] 而不是 v[i]
• 9.high, 使用 x[i+x] 而不是 x[i]
• 10.n 有一个参数是 scalar
• 11.h half narrow, 例如 xx>>1
• 12.hn high narrow, 例如 xx>>8
• 13.p pairwise
• 14.nm max 类指令使用 nm 表示符合 ieee754
• 15.v across vector
• 16.u unsigned, 输入是 signed, 输出变成 unsigned
• 16.s signed, 输入是 unsigned, 输出变成 signed
• 17.n round to nearest even
• 17.m rount to minus inf
• 17.p round to plus inf
• 17.a round to nearest away

某些会 overflow 的计算时会有 saturating 的版本, 用开头的 `q` 表示, 例如:

1. int8x8_t v[q]add_s8(int8x8_t a,int8x8_t b), 加法
2. int8x8_t v[q]movn_s16(int16x8_t a), int16 转换为 int8
3. int8x8_t v[q]shl_s8(int8x8_t a,int8x8_t b), 左移
4. int8x8_t v[q]abs_s8(int8x8_t a), 当 a 为 INT8_MIN 时计算会溢出

整数的右移计算需要舍入, 默认的舍入方法是 minus inf, rounding 表示需要变成 plus inf. 例如:

• 无 rounding 时, 7>>2=3, -7>>2=-4
• 有 rounding 时, 7>>2=4, -7>>2=-3

通过开头加 `r` 表示需要 roudning, 例如:

1. int8x8_t v[r]shl_s8(int8x8_t a,int8x8_t b), 相当于 (a+(1<<(n-1)))>>b
2. int8x8_t v[r]hadd_s8(int8x8_t a,int8x8_t b), 因为 hadd 相当于 (a+b)>>1, 所以也有 rounding 的问题

除了整数右移, vrnd 和 vcvt 指令支持指定不同的 rounding 方法, NEON 支持的 rounding 方法主要有:

1. round toward zero

   默认的方法, 也是 c 语言中 float 转型成 int 时使用的方法, 表示 round 到最接近 0 的值, 例如 (int)3.5=3, (int)(-3.5)=-3

   neon 指令没有任何前缀 (n,m,p,a) 时表示使用这种 rounding 方法, 例如:

   int32x2_t vcvt_s32_f32(float32x2_t a)

2. round to nearest with ties to even

   round 到离它最近的偶数, 这是 IEEE754 默认的方法, 在指令时使用 `n` 前缀表示, 例如:

   int32x2_t vcvt[n]_s32_f32(float32x2_t a)

   float32x2_t vrnd[n]_f32(float32x2_t a)

3. round toward minus infinity

   相当于 floor, 在指令时使用 `m` 前缀表示, 例如:

   float32x2_t vrnd[m]_f32(float32x2_t a)

   int32x2_t vcvt[m]_s32_f32(float32x2_t a)

4. round toward plus infinity

   相当于 ceil, 在指令时使用 `p` 前缀表示, 例如:

   float32x2_t vrnd[p]_f32(float32x2_t a)

   int32x2_t vcvt[p]_s32_f32(float32x2_t a)

5. round to nearest with ties to away

   四舍五入, 在指令时使用 `a` 前缀表示, 例如:

   float32x2_t vrnd[a]_f32(float32x2_t a)

   int32x2_t vcvt[a]_s32_f32(float32x2_t a)

不同 rounding 方法的结果如下所示:

默认使用 64-bit vector, 例如 int8x8_t vqadd_s8(int8x8_t a,int8x8_t b) 使用 64-bit vector, 所以只能同时操作 8 个 int8_t, 通过 `q` 后缀, 表示使用 128-bit vector, 例如: int8x16_t vadd[q]_s8(int8x16_t a,int8x16_t b)

通常情况下 NEON 的输入和输出元素的宽度是相同的, 例如 int8x8_t vqadd_s8(int8x8_t a,int8x8_t b) 的输入和输出都是 int8_t. widen 是指把输出元素的宽度变成输出的两倍, 比如输入是 int8_t, 输出变成 int16_t. 用 `l` 后缀表示 widen, 例如: int16x8_t vadd[l]_s8(int8x8_t a,int8x8_t b)

narrow 与 widen 相反, 输出元素的宽度变成输入的一半, 用 `n` 后缀表示, 例如:

int8x8_t vmov[n]_s16(int16x8_t a)

uint8x8_t vqshru[n]_n_s16(int16x8_t a,const int n)

另外, add 指令有特殊的 narrow 方法:

int8x8_t vadd[hn]_s16(int16x8_t a,int16x8_t b), 其中的 `hn` 表示 high narrow, 因为它是取的输入元素的 `high part` 做为 narrow 的结果: r[i]=(a[i]+b[i])>>8

有些指令使用 high/low 后缀, 表示只操作输入或输出的一半元素, 例如:

int8x16_t vmovn_[high]_s16(int8x8_t r,int16x8_t a) 表示输出的后一半元素来自 a

int16x8_t vmovl_[high]_s8(int8x16_t a) 表示 a 只有后一半元素会被 mov 到输出

int16x8_t vshll_[high]_n_s8(int8x16_t a,const int n) 表示 a 的后一半元素会被 shift 后保存到输出中 (a 有 16 个 元素, 但结果只有 8 个元素)

以 pairwise add 为例, 它把两个输入拼接在一起, 计算的结果是 r[i]=a[2i]+a[2i+1], 使用 `p` 前缀表示 pariwise, 例如 int8x8_t v[p]add_s8(int8x8_t a,int8x8_t b)

across vector 相当于 reduction, 使用 `v` 后缀表示, 例如 int8_t vaddv_s8(int8x8_t a), 它计算的是 vector 的 sum

有些指令会把输入的 signed int 变成输出的 unsigned int, 使用 `u` 后缀表示, 例如 uint8x8_t vqmov[u]n_s16(int16x8_t a)

参考这个例子: https://godbolt.org/z/zesG3sxbs

vector extension 依赖于编译器后端是否有 simd 支持 (例如 md 是否支持 V4SI machine mode), 如果不支持, 则 pass_lower_vector 会把 vector 操作变成 scalar 操作

当 vector extension 指定了超过 SIMD 长度的 vector_size 时, 编译器会把它拆分成多个 vector 操作

SIMDe 通过宏 (编译器预定义或用户定义) 控制生成的代码, 例如:

• SIMDE_ARM_NEON_A32V7_NATIVE
• SIMDE_X86_SSE2_NATIVE
• SIMDE_VECTOR_SUBSCRIPT

这几个宏是根据编译器的预定义宏自动设置的, 表示是否支持 neon/sse2, 是否支持 vector extension

以 vaba_s32 为例, 它操作的数据类型是 `4 个 int32 构成的 vector`, SIMDe 定义了两种相关的类型:

1. simde_int32x4_t
2. simde_int32x4_private

以 neon 的 vaba_s32 为例:

/* NOTE: vaba_s32(a,b,c) 执行的操作是 `a += abs(b-c)` */
simde_int32x4_t simde_vabaq_s32(
    simde_int32x4_t a, simde_int32x4_t b, simde_int32x4_t c) {
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
    return vabaq_s32(a, b, c);
#else
    return simde_vaddq_s32(simde_vabdq_s32(b, c), a);
#endif
}

#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
#undef vabaq_s32
#define vabaq_s32(a, b, c) simde_vabaq_s32((a), (b), (c))
#endif
/* ======================================================= */
simde_int32x4_t simde_vabdq_s32(simde_int32x4_t a, simde_int32x4_t b) {
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
    return vabdq_s32(a, b);
#elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE)
    return vec_sub(vec_max(a, b), vec_min(a, b));
#else
    simde_int32x4_private r_, a_ = simde_int32x4_to_private(a),
                              b_ = simde_int32x4_to_private(b);

#if defined(SIMDE_X86_SSE4_1_NATIVE)
    r_.m128i = _mm_sub_epi32(
        _mm_max_epi32(a_.m128i, b_.m128i), _mm_min_epi32(a_.m128i, b_.m128i));
#elif defined(SIMDE_X86_SSE2_NATIVE)
    const __m128i m = _mm_cmpgt_epi32(b_.m128i, a_.m128i);
    r_.m128i =
        _mm_xor_si128(_mm_add_epi32(_mm_sub_epi32(a_.m128i, b_.m128i), m), m);
#else
    SIMDE_VECTORIZE
    for (size_t i = 0; i < (sizeof(r_.values) / sizeof(r_.values[0])); i++) {
        int64_t tmp = HEDLEY_STATIC_CAST(int64_t, a_.values[i]) -
                      HEDLEY_STATIC_CAST(int64_t, b_.values[i]);
        r_.values[i] = HEDLEY_STATIC_CAST(int32_t, tmp < 0 ? -tmp : tmp);
    }
#endif

    return simde_int32x4_from_private(r_);
#endif
}
/* ======================================================= */
simde_int32x4_t simde_vaddq_s32(simde_int32x4_t a, simde_int32x4_t b) {
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
    return vaddq_s32(a, b);
#elif defined(SIMDE_POWER_ALTIVEC_P6_NATIVE)
    return vec_add(a, b);
#else
    simde_int32x4_private r_, a_ = simde_int32x4_to_private(a),
                              b_ = simde_int32x4_to_private(b);

#if defined(SIMDE_X86_SSE2_NATIVE)
    r_.m128i = _mm_add_epi32(a_.m128i, b_.m128i);
#elif defined(SIMDE_VECTOR_SUBSCRIPT_OPS)
    r_.values = a_.values + b_.values;
#else
    SIMDE_VECTORIZE
    for (size_t i = 0; i < (sizeof(r_.values) / sizeof(r_.values[0])); i++) {
        r_.values[i] = a_.values[i] + b_.values[i];
    }
#endif
    return simde_int32x4_from_private(r_);
#endif
}