Question

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

Answer 1

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

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);

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

1 个答案: