Question

我想将浮点值转换为16位无符号整数而不会饱和（换行/溢出）。

#include <iostream>
#include <xmmintrin.h>

void satur_wrap()
{
    const float bigVal = 99000.f;
    const __m128 bigValVec = _mm_set1_ps(bigVal);

    const __m64 outVec64 =_mm_cvtps_pi16(bigValVec);

#if 0
    const __m128i outVec = _mm_movpi64_epi64(outVec64);
#else

    #if 1
        const __m128i outVec  = _mm_packs_epi32(_mm_cvttps_epi32(bigValVec), _mm_cvttps_epi32(bigValVec));
    #else
        const __m128i outVec  = _mm_cvttps_epi32(bigValVec);
    #endif

#endif

    uint16_t *outVals = NULL;
    posix_memalign((void **) &outVals, sizeof(__m128i), sizeof(__m128i));

    _mm_store_si128(reinterpret_cast<__m128i *>(outVals), outVec);

    for (int i = 0; i < sizeof(outVec) / sizeof(*outVals); i++)
    {
        std::cout << "outVals[" << i << "]: " << outVals[i] << std::endl;
    }

    std::cout << std::endl
        << "\tbigVal: " << bigVal << std::endl
        << "\t(unsigned short) bigVal: " << ((unsigned short) bigVal)  << std::endl
        << "\t((unsigned short)((int) bigVal)): " << ((unsigned short)((int) bigVal)) << std::endl
        << std::endl;
}

示例执行：

$ ./row
outVals[0]: 32767
outVals[1]: 32767
outVals[2]: 32767
outVals[3]: 32767
outVals[4]: 32767
outVals[5]: 32767
outVals[6]: 32767
outVals[7]: 32767

        bigVal: 99000
        (unsigned short) bigVal: 65535
        ((unsigned short)((int) bigVal)): 33464

((unsigned short)((int) bigVal))表达式可以正常工作（但它可能是UB，对吧？）。但我找不到与SSE非常相似的东西。我必须遗漏一些东西，但我找不到一个原语来将四个32位float转换为四个32位int。

编辑：哎呀，我认为对于32位整数来说它是“正常的” - ＆gt; 16位无符号整数转换以使用环绕。但我已经知道_mm_packs_epi32使用了signed-saturate（并且似乎没有_mm_packus_epi32）。有没有办法设置模式，或_mm_packus_epi32以外的其他原语？

Answer 1

我认为您可能正在寻找CVTTPS2DQ指令，其内在因素为_mm_cvttps_epi32。请参阅：http://msdn.microsoft.com/en-us/library/c8c5hx3b(v=vs.71).aspx#vcref_mm_cvttps_epi32

这是一个完整的实现，它采用2 x SSE浮点向量并将它们转换为单个压缩的8 x 16位无符号向量，并带有环绕声：

#include <stdio.h>
#include <tmmintrin.h>

__m128i vec_float_to_short(const __m128 v1, const __m128 v2)
{
    __m128i v1i = _mm_cvttps_epi32(v1);
    __m128i v2i = _mm_cvttps_epi32(v2);
    v1i = _mm_shuffle_epi8(v1i, _mm_setr_epi8(0, 1, 4, 5, 8, 9, 12, 13, 255, 255, 255, 255, 255, 255, 255, 255));
    v2i = _mm_shuffle_epi8(v2i, _mm_setr_epi8(255, 255, 255, 255, 255, 255, 255, 255, 0, 1, 4, 5, 8, 9, 12, 13));
    return _mm_or_si128(v1i, v2i);
}

int main(void)
{
    __m128 v1 = _mm_setr_ps(0.0f, 1.0f, -1.0f, 32767.0f);
    __m128 v2 = _mm_setr_ps(-32768.0f, 32768.0f, 99999.0f, -99999.0f);
    __m128i v3 = vec_float_to_short(v1, v2);

    printf("v1 = %vf\n", v1);
    printf("v2 = %vf\n", v2);
    printf("v3 = %vhu\n", v3);

    return 0;
}

请注意，这使用PSHUFB（_mm_shuffle_epi8），它需要SSSE3又名SSE3.5又称MNI（请参阅tmmintrin.h），因此这只适用于合理的当前CPU（来自英特尔在过去6年左右）。

$ gcc -Wall -mssse3 vec_float_to_short.c -o vec_float_to_short
$ ./vec_float_to_short 
v1 = 0.000000 1.000000 -1.000000 32767.000000
v2 = -32768.000000 32768.000000 99999.000000 -99999.000000
v3 = 0 1 65535 32767 32768 32768 34463 31073
$

请注意，并非所有版本的gcc都支持SIMD向量的printf v格式说明符（在本例中我在OS X上使用Apple的gcc）。

Answer 2

我只回答有关32位整数的部分问题 - ＆gt; 16位无符号整数转换。

由于您需要一个环绕式，只需获取包含32位整数的每个双字的低位字。这些16位整数与16位未使用的数据交错，因此将它们打包成连续的数组可能很方便。最简单的方法是使用_mm_shuffle_epi8内在函数（SSSE3）。

如果您希望程序更具可移植性并且只需要SSE2指令集，则可以使用_mm_packs_epi32打包值，但使用以下技巧禁用其饱和行为：

x = _mm_slli_epi32(x, 16);
y = _mm_slli_epi32(y, 16);

x = _mm_srai_epi32(x, 16);
y = _mm_srai_epi32(y, 16);

x = _mm_packs_epi32(x, y);

这个技巧有效，因为它执行16位值的符号扩展，这使得有符号饱和成为无操作。

同样的技巧适用于_mm_packus_epi32：

x = _mm_and_si128(x, _mm_set1_epi32(65535));
y = _mm_and_si128(y, _mm_set1_epi32(65535));
x = _mm_packus_epi32(x, y);

这个技巧有效，因为它执行16位值的零扩展，这使得无符号饱和成为无操作。执行零扩展更容易，但是您需要SSE4.1指令集才能使_mm_packus_epi32可用。

可以使用单个指令打包8个16位整数：_mm_perm_epi8。但这需要非常罕见的XOP指令集。

以下是关于饱和转换的几个词。

如果您将_mm_packus_epi32更改为#include <xmmintrin.h>或#include <smmintrin.h>，事实上#include <x86intrin.h>内在可用。您需要CPU和编译器来支持SSE4.1扩展。

如果您没有兼容SSE4.1的CPU或编译器，或者希望您的程序更具可移植性，请使用以下代码替换_mm_packus_epi32内在函数：

__m128i m1 = _mm_cmpgt_epi32(x, _mm_set1_epi32(0));
__m128i m2 = _mm_cmpgt_epi32(x, _mm_set1_epi32(65535));
x = _mm_and_si128(x, m1);
x = _mm_or_si128(x, m2);

将float向量转换为16位int而不会饱和

2 个答案: