Как я могу сложить два регистра SSE
У меня есть два регистра SSE (128 бит — это один регистр), и я хочу добавить их. Я знаю, как я могу добавить соответствующие слова в них, например, я могу сделать это с _mm_add_epi16 если я использую 16-битные слова в регистрах, но я хочу что-то вроде _mm_add_epi128 (который не существует), который использовал бы регистр как одно большое слово.
Есть ли способ выполнить эту операцию, даже если необходимо несколько инструкций?
Я думал об использовании _mm_add_epi64обнаружение переполнения в правильном слове и добавление 1 к левому слову в регистре, если это необходимо, но я также хотел бы, чтобы этот подход работал для 256-битных регистров (AVX2), и этот подход кажется слишком сложным для этого.
Решение
Добавить два 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);
Другие решения