我正在从文件中执行8位数据的分散读取（De-Interleaving 64 channel wave file）。然后我将它们组合成单个字节流。我遇到的问题是重新构建要写出的数据。
基本上我正在读取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正在做的事情......
我最后的尝试是使用一些代码来制作四个CC（采用移位和ors），然后使用单个_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杂耍指令......在所有的读取和写入都是缓慢的位之后！
任何有任何想法的人都会非常感激！ ：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接近......我仍然对此感到困惑，但是......哼哼。
答案 0 :(得分：2)
也许编译器试图立即将所有内部参数放入寄存器中。您不希望在不组织它们的情况下一次访问那么多变量。
不要为每个样本声明单独的标识符，而是尝试将它们放入char[16]。只要你没有获取数组中任何内容的地址，编译器就会在它认为合适的情况下将16个值提升为寄存器。您可以添加__aligned__标记（或VC ++使用的任何标记），也可以完全避免使用内在标记。否则，使用( sample[15], sample[14], sample[13] … sample[0] )调用内在函数应该可以使编译器的工作更容易，或者至少不会造成伤害。
编辑：我很确定你正在打击寄存器泄漏，但这个建议可能只是单独存储字节，这不是你想要的。我认为我的建议是将您的最终尝试（使用MakeFourCC）与读取操作交错，以确保它正确安排并且没有往返堆栈的往返。当然，检查目标代码是确保目标代码的最佳方法。
基本上，您将数据流式传输到寄存器文件中，然后将其流式传输出去。在刷新数据之前，您不希望超载它。
答案 1 :(得分：2)
VS在优化内在函数方面非常糟糕。特别是从SSE寄存器移动数据到SSE寄存器。内在函数本身使用得很好但是......
你看到的是它试图用这个怪物填充SSE注册：
00AA100C movzx ecx,byte ptr [esp+0Fh]
00AA1011 movzx edx,byte ptr [esp+0Fh]
00AA1016 movzx eax,byte ptr [esp+0Fh]
00AA101B movd xmm0,eax
00AA101F movzx eax,byte ptr [esp+0Fh]
00AA1024 movd xmm2,edx
00AA1028 movzx edx,byte ptr [esp+0Fh]
00AA102D movd xmm1,ecx
00AA1031 movzx ecx,byte ptr [esp+0Fh]
00AA1036 movd xmm4,ecx
00AA103A movzx ecx,byte ptr [esp+0Fh]
00AA103F movd xmm5,edx
00AA1043 movzx edx,byte ptr [esp+0Fh]
00AA1048 movd xmm3,eax
00AA104C movzx eax,byte ptr [esp+0Fh]
00AA1051 movdqa xmmword ptr [esp+60h],xmm0
00AA1057 movd xmm0,edx
00AA105B movzx edx,byte ptr [esp+0Fh]
00AA1060 movd xmm6,eax
00AA1064 movzx eax,byte ptr [esp+0Fh]
00AA1069 movd xmm7,ecx
00AA106D movzx ecx,byte ptr [esp+0Fh]
00AA1072 movdqa xmmword ptr [esp+20h],xmm4
00AA1078 movdqa xmmword ptr [esp+80h],xmm0
00AA1081 movd xmm4,ecx
00AA1085 movzx ecx,byte ptr [esp+0Fh]
00AA108A movdqa xmmword ptr [esp+70h],xmm2
00AA1090 movd xmm0,eax
00AA1094 movzx eax,byte ptr [esp+0Fh]
00AA1099 movdqa xmmword ptr [esp+10h],xmm4
00AA109F movdqa xmmword ptr [esp+50h],xmm6
00AA10A5 movd xmm2,edx
00AA10A9 movzx edx,byte ptr [esp+0Fh]
00AA10AE movd xmm4,eax
00AA10B2 movzx eax,byte ptr [esp+0Fh]
00AA10B7 movd xmm6,edx
00AA10BB punpcklbw xmm0,xmm1
00AA10BF punpcklbw xmm2,xmm3
00AA10C3 movdqa xmm3,xmmword ptr [esp+80h]
00AA10CC movdqa xmmword ptr [esp+40h],xmm4
00AA10D2 movd xmm4,ecx
00AA10D6 movdqa xmmword ptr [esp+30h],xmm6
00AA10DC movdqa xmm1,xmmword ptr [esp+30h]
00AA10E2 movd xmm6,eax
00AA10E6 punpcklbw xmm4,xmm5
00AA10EA punpcklbw xmm4,xmm0
00AA10EE movdqa xmm0,xmmword ptr [esp+50h]
00AA10F4 punpcklbw xmm1,xmm0
00AA10F8 movdqa xmm0,xmmword ptr [esp+70h]
00AA10FE punpcklbw xmm6,xmm7
00AA1102 punpcklbw xmm6,xmm2
00AA1106 movdqa xmm2,xmmword ptr [esp+10h]
00AA110C punpcklbw xmm2,xmm0
00AA1110 movdqa xmm0,xmmword ptr [esp+20h]
00AA1116 punpcklbw xmm1,xmm2
00AA111A movdqa xmm2,xmmword ptr [esp+40h]
00AA1120 punpcklbw xmm2,xmm0
00AA1124 movdqa xmm0,xmmword ptr [esp+60h]
00AA112A punpcklbw xmm3,xmm0
00AA112E punpcklbw xmm2,xmm3
00AA1132 punpcklbw xmm6,xmm4
00AA1136 punpcklbw xmm1,xmm2
00AA113A punpcklbw xmm6,xmm1
这样做效果更好，而且（应该）更快：
__declspec(align(16)) BYTE arr[16] = { sample15, sample14, sample13, sample12, sample11, sample10, sample9, sample8, sample7, sample6, sample5, sample4, sample3, sample2, sample1, sample0 };
__m128i packedSamples = _mm_load_si128( (__m128i*)arr );
建立我自己的试验台：
void f()
{
const int steps = 1000000;
BYTE* pDest = new BYTE[steps*16+16];
pDest += 16 - ((ULONG_PTR)pDest % 16);
BYTE* pSrc = new BYTE[steps*16*16];
const int channelStep0 = 0;
const int channelStep1 = 1;
const int channelStep2 = 2;
const int channelStep3 = 3;
const int channelStep4 = 16;
__int64 freq;
QueryPerformanceFrequency( (LARGE_INTEGER*)&freq );
__int64 start = 0, end;
QueryPerformanceCounter( (LARGE_INTEGER*)&start );
for( int step = 0; step < steps; ++step )
{
__declspec(align(16)) BYTE arr[16];
for( int j = 0; j < 4; ++j )
{
//for( int i = 0; i < 4; ++i )
{
arr[0+j*4] = *(pSrc + channelStep0);
arr[1+j*4] = *(pSrc + channelStep1);
arr[2+j*4] = *(pSrc + channelStep2);
arr[3+j*4] = *(pSrc + channelStep3);
}
pSrc += channelStep4;
}
#if test1
// test 1 with C
for( int i = 0; i < 16; ++i )
{
*(pDest + step * 16 + i) = arr[i];
}
#else
// test 2 with SSE load/store
__m128i packedSamples = _mm_load_si128( (__m128i*)arr );
_mm_stream_si128( ((__m128i*)pDest) + step, packedSamples );
#endif
}
QueryPerformanceCounter( (LARGE_INTEGER*)&end );
printf( "%I64d", (end - start) * 1000 / freq );
}
对我来说，测试2比测试1快。
我做错了吗？这不是您使用的代码吗？我错过了什么？这只适合我吗？
答案 2 :(得分：-3)
使用内在函数中断编译器优化！
内部函数的重点是将编译器不知道的操作码插入编译器确实知道并生成的操作码流中。除非给编译器一些关于操作码的元数据以及它如何影响寄存器和内存，否则编译器不能假设在执行内部函数后保留任何数据。这真的伤害了编译器的优化部分 - 它不能对内部函数的指令重新排序，它不能假设寄存器不受影响等等。
我认为优化这种方法的最佳方法是查看更大的图片 - 您需要考虑从读取源数据到编写最终输出的整个过程。微观优化很少会产生很大的结果，除非你开始做一些非常糟糕的事情。
也许，如果你详细说明所需的输入和输出，这里有人可以建议一个最佳的方法来处理它。