使用 Intel 内在函数的位反向重新排序优化

Question

前段时间，我使用 SSE 内在函数优化了一个 radix2 函数，我几乎接近 FFTW 性能，所以，我的下一步是优化我在原始代码中找到的位反向重新排序函数，老实说，我想优化它。原来的代码是这样的：

void bit_reverse_reorder(float *x,float *y, int N)
{
   int bits=0;
   int i, j, k;
   float tempr, tempi;
   //MAXPOW = 12

   for (i=0; i<MAXPOW; i++)
      if (pow_2[i]==N) bits=i;

   for (i=0; i<N; i++)
   {
      j=0;
      for (k=0; k<bits; k++)
         if (i&pow_2[k]) j+=pow_2[bits-k-1];
      if (j>i)
      {
        tempr=x[i];
        tempi=y[i];
        x[i]=x[j];
        y[i]=y[j];
        x[j]=tempr;
        y[j]=tempi;
      }
   }
}

int main()
{
   radix2(re,im,N);

   bit_reverse_reorder(re,im,N);
}

PS：pow_2[] 是一个预先计算好的数组，包含 2 的幂 (1,2,4,8,16,32,...)，N 是元素的数量 = 4096 , *x 和 *y 分别表示输入数据的每个元素的实部和虚部。

radix2 生成未排序的结果，因此所述函数重新排序结果。

首先，我并没有完全理解这个位反转是如何工作的！所以，我认为如果有人给我关于这个功能如何工作的提示会很好。

其次，我打算使用 SSE 内在函数来增强此函数的性能，那么是否有任何 2 条指令向量可用于交换循环？

Answer 1

感谢@nwellnhof 的评论，我对交换功能进行了如下修改：

void bit_reverse_reorder(float *x,float *y, int N)
{
   unsigned i,j;
   for (i = 0, j = 0; i < N; i++) {
      if (i < j) 
      {
         float tmpx = x[i];
         x[i] = x[j];
         x[j] = tmpx;

         float tmpy = y[i];
         y[i] = y[j];
         y[j] = tmpy;
      }
      unsigned bit = ~i & (i + 1);

      unsigned rev = (N / 2) / bit;

      j ^= (N - 1) & ~(rev - 1);
   }
}

现在我在函数内部的 for 循环中获得了 54 900 个循环的性能，这也很好:)

Answer 2

根据您的建议，我进行了一些修改以增强功能性能。

首先，我通过移位指令替换了 power_2[] 调用。

然后，我制作了一个交换函数，它使用 add/sub 操作进行交换，而不使用第三个变量。

void swap(float* a, float* b)
{
 *a = *a+*b;
 *b = *a-*b;
 *a = *a-*b;
}

void bit_reverse_reorder(float *x,float *y, int N)
{
   int bits=0;
   int i, j, k;
   unsigned pow_bits=0;

   for (i=0; i<MAXPOW; i++)
      if (1 << i==N) bits=i-1;
      for (i=1; i<N; i++)
      {
          j=0;
          unsigned pow_2k=0,pow_2kj;

          for (k=0; k<bits; k++)
          {
             pow_2k = 1<<k;
             pow_2kj = 1<<(bits-k);
             if (i&pow_2k) j+=pow_2kj;
          }
          if (j>i)
          {
             swap(&x[i],&x[j]);
             swap(&y[i],&y[j]);
          }
       }
}

周期数从近 500 000 个周期减少到大约 180 000 个周期。