Question

我有一个循环来反转数组中的元素。我已将问题简化并简化为以下内容：

for (int x=0;x<w/2;++x) {
    int il =     x;
    int ir = w-1-x;
    type_copy l = data[il];
    type_copy r = data[ir];
    data[il] = r;
    data[ir] = l;
}

此代码会反转元素，但速度相当慢。首先，它不能自动矢量化，因为数组访问是不连续的。另一方面，右侧的访问是从理想的缓存遍历向后进行的。最后，可能存在一些停滞，因为下一个循环周期的加载不会发生在最后一个循环周期的数据提交之前，因为编译器可能无法判断自带别名的指针是否自动命中。

就我而言，sizeof(type_copy)是4*sizeof(uint8_t) = 4或4*sizeof(float) = 4*4 = 16。因此，请注意字节级反转是不可接受的。

我的问题是：该代码如何优化，如果可以的话？

Answer 1

您的代码无法很好地并行化的原因是因为数据之间存在依赖关系：

for (int x=0;x<w/2;++x) {
   int il =     x;
   int ir = w-1-x;
   type_copy l = data[il];
   type_copy r = data[ir];
   data[il] = r;
   data[ir] = l;
}

此处有3项操作：compute l/r indexes，read from array，write to array。这些中的每一个都取决于先前操作的结果，因此它们不能并行完成。注意我在同一类别下将左侧或右侧的操作分组。

要做的第一件事是尝试制动依赖性。

不是在同一周期中阅读广告写作，而是尝试读取迭代N的数据并为迭代N-1写入数据;这可以在同一个循环中完成。

int il =   0;
int ir = w-1;
type_copy l = data[il];
type_copy r = data[ir];

for (int x=0;x<w/2;++x) {
   data[il] = r;
   data[ir] = l;
   il =     x;
   ir = w-1-x;
   l = data[il];
   r = data[ir];       
}

甚至更好，预先计算用于阅读的索引：

int il_0 =   0;
int ir_0 = w-1;
int il_1 =   1;
int ir_1 = w-2;
type_copy l = data[il_0];
type_copy r = data[ir_0];

for (int x=0;x<w/2;++x) {
   data[il_0] = r;
   data[ir_0] = l;       
   l = data[il_1];
   r = data[ir_1];
   il_0 = il_1;
   ir_0 = ir_1;       
   il_1 = il_1++; 
   ir_1 = ir_1--;
}

值得尝试的另一件事是复制多个数据样本;例如，在同一周期中读/写2,4，..等样本。这应该可以改善代码的并行性。

Answer 2

假设您的数据类型如下：

struct float_data
{
    float f1;
    float f2;
    float f3;
    float f4;
};

struct uint8_t_data
{
    uint8_t f1;
    uint8_t f2;
    uint8_t f3;
    uint8_t f4;
};

您可以尝试SSE内在函数。对于uint8_t_data，速度有了很大提升：

typedef uint8_t_data type_copy;

for (int x = 0; x<w / 2; x += 4) 
{
    int il = x;
    int ir = w - 1 - x - 3;

    __m128i dl = _mm_loadu_si128((const __m128i*)&data[il]);
    __m128i dr = _mm_loadu_si128((const __m128i*)&data[ir]);
    _mm_storeu_si128((__m128i*)&data[ir], _mm_shuffle_epi32(dl, _MM_SHUFFLE(0, 1, 2, 3)));
    _mm_storeu_si128((__m128i*)&data[il], _mm_shuffle_epi32(dr, _MM_SHUFFLE(0, 1, 2, 3)));
}

输出：

g++ -O3 non vectorized: 16ms
g++ -O3 vectorized: 5ms

然而，对于float_data，速度没有太大提升：

typedef float_data type_copy;

for (int x = 0; x<w / 2; x+=2) {
    int il = x;
    int ir = w - 1 - x - 1;

    __m256 dl = _mm256_loadu_ps((const float*)&data[il]);
    __m256 dr = _mm256_loadu_ps((const float*)&data[ir]);

    _mm256_storeu_ps((float*)&data[ir], _mm256_permute2f128_ps(dl, dl, 1));
    _mm256_storeu_ps((float*)&data[il], _mm256_permute2f128_ps(dr, dr, 1));

}

输出：

g++ -O3 -mavx non vectorized: 27ms
g++ -O3 -msse4.2 non vectorized: 25ms
g++ -O3 -mavx vectorized: 24ms

Answer 3

希望它更好：

for (int x=0;x<w/2;++x) {
    std::swap(data[x], data[w-i-x]);    
}

如果您不想使用标准模板库函数，请按如下方式减少赋值和局部变量的数量：

与您的实施相比删除了3个本地变量
删除了3个额外的分配操作

for (int x=0;x<w/2;++x) { type_copy l = data[x]; data[x] = data[w-1-x]; data[w-l-x] = l; }

Answer 4

代码肯定可以优化，但这样做可能取决于平台。例如，AMD64从x86 SSE继承了一堆有用的指令，包括PSHUFD或VPPERM，它们可以在矢量中任意重新排序字，而MASKMOVDQU可以组合部分写入。

优化项目的逆转

4 个答案: