Как я могу сложить два регистра SSE

Добавить два 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);

Это основано на этой ссылке как-может-я-надстройку и-вычитать-128-битовые целые числа-в-с-или-с.

Функция unsigned_lessthan определяется ниже. Это сложно без AMD XOP (на самом деле найдена более простая версия для SSE4.2, если XOP недоступен — см. Конец моего ответа). Вероятно, некоторые другие люди здесь могут предложить лучший метод. Вот некоторый код, показывающий это работает.

#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]);
}

Редактировать:

Единственный потенциально эффективный способ добавить 128-битные или 256-битные числа с SSE — это XOP. Единственный вариант с AVX будет XOP2, который еще не существует. И даже если у вас есть XOP, может быть эффективно добавить только два 128-битных или 256-разрядных числа параллельно (вы могли бы сделать четыре с AVX, если XOP2 существует), чтобы избежать горизонтальных инструкций, таких как 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");
}

Изменить: на основе комментария Стивена Канона в насыщенная-AVX-вычитание или-sse4-2 Я обнаружил, что есть более эффективный способ сравнения беззнаковых 64-битных чисел с SSE4.2, если XOP недоступен.

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