Как выполнить преобразование uint32/float с SSE?

В SSE есть функция _mm_cvtepi32_ps(__m128i input) который принимает входной вектор 32-битных целых чисел со знаком (int32_t) и преобразует их в floats.

Теперь я хочу интерпретировать входные целые числа как не подписанные. Но нет функции _mm_cvtepu32_ps и я не мог найти реализацию одного. Вы знаете, где я могу найти такую ​​функцию или хотя бы дать подсказку о реализации? Чтобы проиллюстрировать разницу в результатах:

unsigned int a = 2480160505; // 10010011 11010100 00111110 11111001   
float a1 = a; // 01001111 00010011 11010100 00111111;  
float a2 = (signed int)a; // 11001110 11011000 01010111 10000010
Источник

3 ответа

Решение

Эта функциональность существует в AVX-512, но если вы не можете ждать до тех пор, единственное, что я могу предложить, - это преобразовать unsigned int введите значения в пары меньших значений, преобразуйте их, а затем снова сложите их вместе, например,

inline __m128 _mm_cvtepu32_ps(const __m128i v)
{
    __m128i v2 = _mm_srli_epi32(v, 1);     // v2 = v / 2
    __m128i v1 = _mm_sub_epi32(v, v2);     // v1 = v - (v / 2)
    __m128 v2f = _mm_cvtepi32_ps(v2);
    __m128 v1f = _mm_cvtepi32_ps(v1);
    return _mm_add_ps(v2f, v1f); 
}

ОБНОВИТЬ

Как отметил wim в своем ответе, вышеприведенное решение не работает при входном значении UINT_MAX, Вот более надежное, но чуть менее эффективное решение, которое должно работать на полную uint32_t Диапазон ввода:

inline __m128 _mm_cvtepu32_ps(const __m128i v)
{
    __m128i v2 = _mm_srli_epi32(v, 1);                 // v2 = v / 2
    __m128i v1 = _mm_and_si128(v, _mm_set1_epi32(1));  // v1 = v & 1
    __m128 v2f = _mm_cvtepi32_ps(v2);
    __m128 v1f = _mm_cvtepi32_ps(v1);
    return _mm_add_ps(_mm_add_ps(v2f, v2f), v1f);      // return 2 * v2 + v1
}
Источник

С помощью решения Пола Р. и моего предыдущего решения разница между округленной плавающей точкой и исходным целым числом меньше или равна 0,75 ULP (единица в последнем месте). В этих методах в двух местах может происходить округление: в _mm_cvtepi32_ps и в _mm_add_ps. Это приводит к результатам, которые не настолько точны, насколько это возможно для некоторых входных данных.

Например, с помощью метода Пола Р. 0x2000003=33554435 преобразуется в 33554432.0, но 33554436.0 также существует как число с плавающей точкой, что было бы лучше здесь. Мое предыдущее решение страдает от подобных неточностей. Такие неточные результаты могут также возникать с кодом, сгенерированным компилятором, см. Здесь.

Следуя подходу gcc (см. Ответ Питера Кордеса на этот другой вопрос SO), получается точное преобразование в пределах 0,5 ULP:

inline __m128 _mm_cvtepu32_ps(const __m128i v)
{
    __m128i msk_lo    = _mm_set1_epi32(0xFFFF);
    __m128  cnst65536f= _mm_set1_ps(65536.0f);

    __m128i v_lo      = _mm_and_si128(v,msk_lo);          /* extract the 16 lowest significant bits of v                                   */
    __m128i v_hi      = _mm_srli_epi32(v,16);             /* 16 most significant bits of v                                                 */
    __m128  v_lo_flt  = _mm_cvtepi32_ps(v_lo);            /* No rounding                                                                   */
    __m128  v_hi_flt  = _mm_cvtepi32_ps(v_hi);            /* No rounding                                                                   */
            v_hi_flt  = _mm_mul_ps(cnst65536f,v_hi_flt);  /* No rounding                                                                   */
    return              _mm_add_ps(v_hi_flt,v_lo_flt);    /* Rounding may occur here, mul and add may fuse to fma for haswell and newer    */
}                                                         /* _mm_add_ps is guaranteed to give results with an error of at most 0.5 ULP     */

Обратите внимание, что возможны и другие старшие / младшие биты, если _mm_cvt_ps может преобразовывать обе части в числа с плавающей запятой без округления. Например, раздел с 20 старшими и 12 младшими битами будет работать одинаково хорошо.

Источник

Я думаю, что ответ Павла хороший, но он не подходит для v=4294967295U (=2^32-1). В этом случае v2=2^31-1 и v1=2^31. Внутренний _mm_cvtepi32_ps преобразует 2 ^ 31 в -2.14748365E9 . v2=2^31-1 преобразуется в 2.14748365E9 и, следовательно, _mm_add_ps возвращает 0 (из-за округления v1f и v2f являются точными противоположностями друг другу).

Идея решения ниже состоит в том, чтобы скопировать наиболее значимый бит v в v_high. Другие биты v копируются в v_low. v_high преобразуется в 0 или 2,14748365E9.

inline __m128 _mm_cvtepu32_v3_ps(const __m128i v)
{
__m128i msk0=_mm_set1_epi32(0x7FFFFFFF);
__m128i zero=_mm_xor_si128(msk0,msk0);
__m128i cnst2_31=_mm_set1_epi32(0x4F000000); /* IEEE representation of float 2^31 */

__m128i v_high=_mm_andnot_si128(msk0,v);
__m128i v_low=_mm_and_si128(msk0,v);
__m128  v_lowf=_mm_cvtepi32_ps(v_low);
__m128i msk1=_mm_cmpeq_epi32(v_high,zero);
__m128  v_highf=_mm_castsi128_ps(_mm_andnot_si128(msk1,cnst2_31));  
__m128  v_sum=_mm_add_ps(v_lowf,v_highf);
return v_sum;

}


Обновить

Удалось уменьшить количество инструкций:

inline __m128 _mm_cvtepu32_v4_ps(const __m128i v)
{
__m128i msk0=_mm_set1_epi32(0x7FFFFFFF);
__m128i cnst2_31=_mm_set1_epi32(0x4F000000);

__m128i msk1=_mm_srai_epi32(v,31);
__m128i v_low=_mm_and_si128(msk0,v);
__m128  v_lowf=_mm_cvtepi32_ps(v_low);
__m128  v_highf=_mm_castsi128_ps(_mm_and_si128(msk1,cnst2_31));  
__m128  v_sum=_mm_add_ps(v_lowf,v_highf);
return v_sum;
}

свойственный _mm_srai_epi32 сдвигает наиболее значимый бит v вправо, в то же время сдвигая знаковые биты, что в данном случае оказывается весьма полезным.

Источник
Другие вопросы по тегам