字节数组置换SSE优化

byte array permute SSE optimization

本文关键字：SSE 优化 字节数 数组 字节      更新时间：2023-10-16

我想使用SSE内部函数来翻译这段代码。我发现pshufbSSSE3指令和类似的__builtin_ia32_pshufb128(v128i, v128i)GCC内在可能与此代码一起使用。该代码通过以特定方式交换数组中的字节来通过索引k来置换字节s的向量。

void permutation(int k, std::vector<char> & s) 
{
for(size_t j = 1; j < s.size(); ++j) 
{
std::swap(s[k % (j + 1)], s[j]); 
k = k / (j + 1);
}
}

我花了一个小时思考如何将代码翻译成pshufb。是否可以用单个pshufb排列16个字节，或者需要多个指令？足够好的解决方案一次只排列16个字节。

编辑：问题的进一步背景：我正在迭代s的所有可能的排列。对于相同的s，提前计算k = 0, 1, 2,...的多个结果是可以的。但是，我需要稍后最好将第10个CCD_排列再现为O(1)运算。

单次调用

请注意，您可以在混合基数的位置记法系统中记下数字k，以便此表示中的每个数字都将为j的几个连续值定义交换元素的索引。

例如，对于长度为12的字符串，您可以将任何k写为带基数的三位数：

720 = 1*2*3*4*5*6  (0-th digit, lowest value)
504 = 7*8*9        (1-th digit)
1320 = 10*11*12    (2-th digit, highest value)

现在，您可以为每个位置和该位置中数字的每个值预先计算所有元素的累积排列，并将其保存在查找表中。然后，您就可以通过一条指令进行多次交换。

以下是一个示例(预计算将是最困难的部分)：

//to be precomputed:
__m128i mask0[ 720];
__m128i mask1[ 504];
__m128i mask2[1320];
__m128i permutation(int k, __m128i s) {
s = _mm_shuffle_epi8(s, mask0[k %  720]); k /=  720;  //j = [1..5]
s = _mm_shuffle_epi8(s, mask1[k %  504]); k /=  504;  //j = [6..8]
s = _mm_shuffle_epi8(s, mask2[k       ]);             //j = [9..11]
return s;
}

为了在步骤数量和查找表大小之间取得平衡，可以将分解更改为基。

注意：除法运算非常缓慢。只使用编译时间常数的除法，然后优化器会将它们转换为乘法。检查生成的程序集，以确保没有分割说明。

很多电话

不幸的是，索引计算仍然会占用建议解决方案的大部分时间，请参阅生成的程序集。如果同时处理几个连续的k值，则可以显著减少此开销。

优化解决方案的最简单方法是：分别对k的数字进行迭代，而不是对k进行单个循环。然后指数计算就变得不必要了。此外，还可以重用部分计算的结果。

__m128i s;// = ???
for (int k0 = 0; k0 <  720; k0++) {
__m128i s0 = _mm_shuffle_epi8(s, mask0[k0]);
for (int k1 = 0; k1 <  504; k1++) {
__m128i s1 = _mm_shuffle_epi8(s0, mask1[k1]);
for (int k2 = 0; k2 < 1320; k2+=4) {
//for k = (((k2+0) * BASE1) + k1) * BASE0 + k0:
__m128i sx0 = _mm_shuffle_epi8(s1, mask2[k2+0]);
//for k = (((k2+1) * BASE1) + k1) * BASE0 + k0:
__m128i sx1 = _mm_shuffle_epi8(s1, mask2[k2+1]);
//for k = (((k2+2) * BASE1) + k1) * BASE0 + k0:
__m128i sx2 = _mm_shuffle_epi8(s1, mask2[k2+2]);
//for k = (((k2+3) * BASE1) + k1) * BASE0 + k0:
__m128i sx3 = _mm_shuffle_epi8(s1, mask2[k2+3]);
// ... check four strings: sx0, sx1, sx2, sx3
}
}
}

这样，平均每个排列需要进行一次洗牌(请参阅汇编)，这似乎近乎完美。

代码和结果

以下是所有解决方案的完整工作代码。

请注意，查找表的生成并不是一件简单的事情，而且相应的代码相当大(并且充满了令人讨厌的细节)。

在Intel Core 2 Duo E4700 Allendale(2600MHz)上运行的基准测试给出了以下结果：

2.605 s: original code         (k < 12739451)
0.125 s: single-call fast code (k < 12739451)
4.822 s: single-call fast code (k < 479001600)
0.749 s: many-call fast code   (k < 479001600)

因此，单次调用版本大约比原始代码快20倍，多次调用版本比单次调用版快6.5多倍。

相关文章：