如何将两个 SSE 寄存器加在一起

Question

我有两个 SSE 寄存器（128 位是一个寄存器），我想把它们加起来。我知道如何在其中添加相应的单词，例如，如果我在寄存器中使用 16 位单词，我可以使用 _mm_add_epi16 来完成，但我想要的是类似于 _mm_add_epi128 （不存在），它将使用寄存器作为一个大词。 即使需要多条指令，有什么方法可以执行此操作吗？
我正在考虑使用_mm_add_epi64，检测右字中的溢出，然后在需要时在寄存器的左字中加1，但我也希望这种方法适用于256位寄存器（AVX2），而且这种方法似乎太复杂了为此。

Answer 1

要添加两个 128 位数字 x 和 y 以提供带有 SSE 的 z，您可以这样做

z = _mm_add_epi64(x,y);
c = _mm_unpacklo_epi64(_mm_setzero_si128(), unsigned_lessthan(z,x));
z = _mm_sub_epi64(z,c);

这是基于此链接how-can-i-add-and-subtract-128-bit-integers-in-c-or-c。

函数unsigned_lessthan 定义如下。没有 AMD XOP 会很复杂（如果 XOP 不可用，实际上找到了一个更简单的 SSE4.2 版本 - 请参阅我答案的结尾）。可能这里的其他一些人可以提出更好的方法。这是一些显示此工作的代码。

#include <stdint.h>
#include <x86intrin.h>
#include <stdio.h>

inline __m128i unsigned_lessthan(__m128i a, __m128i b) {
#ifdef __XOP__  // AMD XOP instruction set
    return _mm_comgt_epu64(b,a));
#else  // SSE2 instruction set
    __m128i sign32  = _mm_set1_epi32(0x80000000);          // sign bit of each dword
    __m128i aflip   = _mm_xor_si128(b,sign32);             // a with sign bits flipped
    __m128i bflip   = _mm_xor_si128(a,sign32);             // b with sign bits flipped
    __m128i equal   = _mm_cmpeq_epi32(b,a);                // a == b, dwords
    __m128i bigger  = _mm_cmpgt_epi32(aflip,bflip);        // a > b, dwords
    __m128i biggerl = _mm_shuffle_epi32(bigger,0xA0);      // a > b, low dwords copied to high dwords
    __m128i eqbig   = _mm_and_si128(equal,biggerl);        // high part equal and low part bigger
    __m128i hibig   = _mm_or_si128(bigger,eqbig);          // high part bigger or high part equal and low part
    __m128i big     = _mm_shuffle_epi32(hibig,0xF5);       // result copied to low part
    return big;
#endif
}

int main() {
    __m128i x,y,z,c;
    x = _mm_set_epi64x(3,0xffffffffffffffffll);
    y = _mm_set_epi64x(1,0x2ll);
    z = _mm_add_epi64(x,y);
    c = _mm_unpacklo_epi64(_mm_setzero_si128(), unsigned_lessthan(z,x));
    z = _mm_sub_epi64(z,c);

    int out[4];
    //int64_t out[2];
    _mm_storeu_si128((__m128i*)out, z);
    printf("%d %d\n", out[2], out[0]);
}

编辑：

使用 SSE 添加 128 位或 256 位数字的唯一可能有效的方法是使用 XOP。 AVX 的唯一选择是尚不存在的 XOP2。即使您有 XOP，也只能并行添加两个 128 位或 256 位数字（如果存在 XOP2，您可以使用 AVX 做四个）以避免水平指令，例如 mm_unpacklo_epi64。

一般来说，最好的解决方案是将寄存器压入堆栈并使用标量运算。假设您有两个 256 位寄存器 x4 和 y4，您可以像这样添加它们：

__m256i x4, y4, z4;

uint64_t x[4], uint64_t y[4], uint64_t z[4]    
_mm256_storeu_si256((__m256i*)x, x4);
_mm256_storeu_si256((__m256i*)y, y4);
add_u256(x,y,z);
z4 = _mm256_loadu_si256((__m256i*)z);

void add_u256(uint64_t x[4], uint64_t y[4], uint64_t z[4]) {
    uint64_t c1 = 0, c2 = 0, tmp;
    //add low 128-bits
    z[0] = x[0] + y[0];
    z[1] = x[1] + y[1];
    c1 += z[1]<x[1];
    tmp = z[1];
    z[1] += z[0]<x[0];
    c1 += z[1]<tmp;
    //add high 128-bits + carry from low 128-bits
    z[2] = x[2] + y[2];
    c2 += z[2]<x[2];
    tmp = z[2];
    z[2] += c1;
    c2 += z[2]<tmp; 
    z[3] = x[3] + y[3] + c2;
}

int main() {
    uint64_t x[4], y[4], z[4];
    x[0] = -1; x[1] = -1; x[2] = 1; x[3] = 1;
    y[0] = 1; y[1] = 1; y[2] = 1; y[3] = 1;
    //z = x + y  (x3,x2,x1,x0) = (2,3,1,0)
    //x[0] = -1; x[1] = -1; x[2] = 1; x[3] = 1;
    //y[0] = 1; y[1] = 0; y[2] = 1; y[3] = 1;
    //z = x + y  (x3,x2,x1,x0) = (2,3,0,0)
    add_u256(x,y,z);
    for(int i=3; i>=0; i--) printf("%u ", z[i]); printf("\n");
}

编辑：根据 Stephen Canon 在saturated-substraction-avx-or-sse4-2 的评论，我发现如果 XOP 不可用，有一种更有效的方法可以将无符号 64 位数字与 SSE4.2 进行比较。

__m128i a,b;
__m128i sign64 = _mm_set1_epi64x(0x8000000000000000L);
__m128i aflip = _mm_xor_si128(a, sign64);
__m128i bflip = _mm_xor_si128(b, sign64);
__m128i cmp = _mm_cmpgt_epi64(aflip,bflip);