c++ - VC++ SSE 内在优化怪异

Question

我正在从文件中分散读取 8 位数据(对 64 channel 波形文件进行反交织)。然后我将它们组合成一个字节流。我遇到的问题是重新构建要写出的数据。

基本上，我读取 16 个字节，然后将它们构建到单个 __m128i 变量中，然后使用 _mm_stream_ps 将值写回内存。但是我有一些奇怪的性能结果。

在我的第一个方案中，我使用 _mm_set_epi8 内在函数来设置我的 __m128i，如下所示:

    const __m128i packedSamples = _mm_set_epi8( sample15,   sample14,   sample13,   sample12,   sample11,   sample10,   sample9,    sample8,
                                                sample7,    sample6,    sample5,    sample4,    sample3,    sample2,    sample1,    sample0 );

基本上我让编译器决定如何优化它以获得最佳性能。这给出了最差的性能。我的测试运行时间约为 0.195 秒。

其次，我尝试使用 4 条 _mm_set_epi32 指令向下合并，然后将它们打包:

    const __m128i samples0      = _mm_set_epi32( sample3, sample2, sample1, sample0 );
    const __m128i samples1      = _mm_set_epi32( sample7, sample6, sample5, sample4 );
    const __m128i samples2      = _mm_set_epi32( sample11, sample10, sample9, sample8 );
    const __m128i samples3      = _mm_set_epi32( sample15, sample14, sample13, sample12 );

    const __m128i packedSamples0    = _mm_packs_epi32( samples0, samples1 );
    const __m128i packedSamples1    = _mm_packs_epi32( samples2, samples3 );
    const __m128i packedSamples     = _mm_packus_epi16( packedSamples0, packedSamples1 );

这确实在一定程度上提高了性能。我的测试现在运行时间约为 0.15 秒。这样做会提高性能似乎违反直觉，因为我认为这正是 _mm_set_epi8 正在做的事情......

我最后的尝试是使用我的一些代码，这些代码是通过以老式方式(使用移位和 OR)制作四个 CC，然后使用单个 _mm_set_epi32 将它们放入 __m128i 中。

    const GCui32 samples0       = MakeFourCC( sample0, sample1, sample2, sample3 );
    const GCui32 samples1       = MakeFourCC( sample4, sample5, sample6, sample7 );
    const GCui32 samples2       = MakeFourCC( sample8, sample9, sample10, sample11 );
    const GCui32 samples3       = MakeFourCC( sample12, sample13, sample14, sample15 );
    const __m128i packedSamples = _mm_set_epi32( samples3, samples2, samples1, samples0 );

这提供了更好的性能。需要大约 0.135 秒来运行我的测试。我真的开始感到困惑了。

所以我尝试了一个简单的读字节写字节系统，它甚至比最后一种方法快一点点。

那么这是怎么回事呢？这一切对我来说似乎违反直觉。

我考虑过延迟发生在 _mm_stream_ps 上的想法，因为我提供数据的速度太快了，但无论我做什么，我都会得到完全相同的结果。前两种方法是否可能意味着 16 个负载无法通过循环分配以隐藏延迟？如果是这样，这是为什么？当然，内在允许编译器在它喜欢的地方进行优化..我认为这就是重点......当然执行 16 次读取和 16 次写入将比 16 次读取和 1 次写入慢得多，并且有一堆 SSE 杂耍instructions ...毕竟它的读写速度很慢!

任何对正在发生的事情有任何想法的人将不胜感激! :D

编辑:根据下面的评论，我停止将字节预加载为常量并将其更改为:

    const __m128i samples0      = _mm_set_epi32( *(pSamples + channelStep3), *(pSamples + channelStep2), *(pSamples + channelStep1), *(pSamples + channelStep0) );
    pSamples    += channelStep4;
    const __m128i samples1      = _mm_set_epi32( *(pSamples + channelStep3), *(pSamples + channelStep2), *(pSamples + channelStep1), *(pSamples + channelStep0) );
    pSamples    += channelStep4;
    const __m128i samples2      = _mm_set_epi32( *(pSamples + channelStep3), *(pSamples + channelStep2), *(pSamples + channelStep1), *(pSamples + channelStep0) );
    pSamples    += channelStep4;
    const __m128i samples3      = _mm_set_epi32( *(pSamples + channelStep3), *(pSamples + channelStep2), *(pSamples + channelStep1), *(pSamples + channelStep0) );
    pSamples    += channelStep4;

    const __m128i packedSamples0    = _mm_packs_epi32( samples0, samples1 );
    const __m128i packedSamples1    = _mm_packs_epi32( samples2, samples3 );
    const __m128i packedSamples     = _mm_packus_epi16( packedSamples0, packedSamples1 );

这将性能提高到约 0.143 秒。 Sitll 不如直接的 C 实现 ...

再次编辑:迄今为止我获得的最佳表现是

    // Load the samples.
    const GCui8 sample0     = *(pSamples + channelStep0);
    const GCui8 sample1     = *(pSamples + channelStep1);
    const GCui8 sample2     = *(pSamples + channelStep2);
    const GCui8 sample3     = *(pSamples + channelStep3);

    const GCui32 samples0   = Build32( sample0, sample1, sample2, sample3 );
    pSamples += channelStep4;

    const GCui8 sample4     = *(pSamples + channelStep0);
    const GCui8 sample5     = *(pSamples + channelStep1);
    const GCui8 sample6     = *(pSamples + channelStep2);
    const GCui8 sample7     = *(pSamples + channelStep3);

    const GCui32 samples1   = Build32( sample4, sample5, sample6, sample7 );
    pSamples += channelStep4;

    // Load the samples.
    const GCui8 sample8     = *(pSamples + channelStep0);
    const GCui8 sample9     = *(pSamples + channelStep1);
    const GCui8 sample10    = *(pSamples + channelStep2);
    const GCui8 sample11    = *(pSamples + channelStep3);

    const GCui32 samples2       = Build32( sample8, sample9, sample10, sample11 );
    pSamples += channelStep4;

    const GCui8 sample12    = *(pSamples + channelStep0);
    const GCui8 sample13    = *(pSamples + channelStep1);
    const GCui8 sample14    = *(pSamples + channelStep2);
    const GCui8 sample15    = *(pSamples + channelStep3);

    const GCui32 samples3   = Build32( sample12, sample13, sample14, sample15 );
    pSamples += channelStep4;

    const __m128i packedSamples = _mm_set_epi32( samples3, samples2, samples1, samples0 );

    _mm_stream_ps( pWrite + 0,  *(__m128*)&packedSamples ); 

这让我在大约 0.095 秒内完成处理，这要好得多。不过，我似乎无法接近 SSE……我仍然对此感到困惑，但是……呵呵。

Answer 1

也许编译器正试图将内部函数的所有参数一次性放入寄存器中。您不想在不组织变量的情况下一次访问那么多变量。

与其为每个样本声明一个单独的标识符，不如尝试将它们放入 char[16] 中。只要您不获取数组中任何内容的地址，编译器就会将这 16 个值提升到它认为合适的寄存器中。您可以添加一个 __aligned__ 标记(或任何 VC++ 使用的标记)并可能完全避免使用内在标记。否则，使用 ( sample[15], sample[14], sample[13] … sample[0] ) 调用内在函数应该会使编译器的工作更容易或者至少不会造成伤害。

---

编辑:我很确定您正在与寄存器溢出作斗争，但该建议可能只是单独存储字节，这不是您想要的。我认为我的建议是将您的最终尝试(使用 MakeFourCC)与读取操作交织在一起，以确保它被正确安排并且没有往返堆栈。当然，检查目标代码是确保这一点的最佳方法。

本质上，您是将数据流式传输到寄存器文件中，然后再将其流式传输回来。在刷新数据之前，您不希望它重载。