Question

我想优化一些持有约400万无符号短裤的数据阵列的重新排序。目的是通过使应该彼此相似的值彼此接近来处理数据流。伪代码是这样的：

  for( i=0; i<n; i++)
    dest[i] = src[ idx[i] ] ;

为优化idx[i]的特定列表的代码，我尝试编译一个400万行的c函数，并使用填充的idx值：

void reorder( unsigned short * restrict i, unsigned short * restrict o) {
  o[0]=i[2075723];
  o[1]=i[2075724];
  o[2]=i[2075722];
  ...
  o[4194301]=i[4192257];
  o[4194302]=i[4192256];
  o[4194303]=i[4190208];
 }

我曾希望让GCC创建一个巧妙的pshufw / pblend / unpack指令流...而是在用完大量内存（7 GB）后挂起。我试图制作基于副本的版本，以避免原地进行交换的复杂性。

有人能提出建议的方法来产生优化的代码来解决此问题吗？到目前为止，我尝试过：

有序阅读，随机写入：60毫秒（openmp无效）
有序写入，随机读取：20毫秒（openmp-> 4毫秒）

我希望最终能接近内存带宽（0.4毫秒）。考虑到缓存大小并进行阻止的方案应该会有所帮助，但我不知道从哪里开始设计它。我也想知道是否有一种简单的方法来利用SIMD指令？

通过转置制作玩具示例，我什至无法让gcc输出SIMD版本，请参阅：

https://godbolt.org/z/bzGWad

这对编译器来说是一个难题吗？还是我缺少一些简单的东西？

编辑21/11/2018添加了完整但最小的问题示例

这是我要优化的问题的完整示例。实际上，排序是一个更复杂的功能，但重点只是根据数据像素与图像中心的距离来对其进行排序，就像展开螺旋一样。

#include <omp.h>
#include <vector>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <algorithm>

#define N 2048

// Sorting on output, one core
void reorder_simple( const std::vector<size_t> &indices,
             const unsigned short input[],
             unsigned short output[]){
  for( int i=0; i<N*N; i++)
    output[i] = input[ indices[i] ];
}
// Sorting on output write, many cores
void reorder_omp( const std::vector<size_t> &indices,
          const unsigned short input[],
          unsigned short output[]){
#pragma omp parallel for
  for( int i=0; i<N*N; i++)
    output[i] = input[ indices[i] ];
}
// Benchmark for memory throughput, one core
void copy_simple(  const std::vector<size_t> &indices,
           const unsigned short input[],
           unsigned short output[]){
  for( int i=0; i<N*N; i++)
    output[i] = input[i];
}
// Benchmark for memory throughput, many cores
void copy_omp (  const std::vector<size_t> &indices,
         const unsigned short input[],
         unsigned short output[]){
#pragma omp parallel for
  for( int i=0; i<N*N; i++)
    output[i] = input[i];
}

// Macro to avoid retyping
#define bench(func)                                          \
  func( indices, input, output);                             \
  start = omp_get_wtime();                                   \
  for( size_t i=0; i<100; i++)                               \
      func( indices, input, output );                        \
  end =  omp_get_wtime();                                    \
  std:: cout << std::setw(15) << #func <<                    \
     ", Time taken: "  << (end-start)/100 << " /s\n";

int main()
{
  std::vector<float> sort_order(N*N);
  std::vector<size_t> indices(N*N);
  float radius, azimuth, ci, cj;
  double start, end;
  unsigned short *input, *output;

  ci = N*0.496;  // changes according to calibration
  cj = N*0.4985;  // reality is more complicated (tilts etc)
  for( size_t i=0; i<N; i++){
    for( size_t j=0; j<N; j++){
      radius  = sqrt( (i-ci)*(i-ci) + (j-cj)*(j-cj) );
      azimuth = atan2( i-ci, j-cj ); // from -pi to pi
      sort_order[i*N+j] = round( radius ) + azimuth/2/M_PI;
      indices[i*N+j] = i*N+j;
    }
  }
  // Find the order to sort data onto a spiral 
  std::sort( indices.begin(), indices.end(),
         [&sort_order](int i, int j){
           return sort_order[i] < sort_order[j]; });
  // Invent some test data
  input = new unsigned short [N*N];
  output = new unsigned short [N*N];
  for( size_t i=0 ; i<N*N; i++){
    input[i] = i;
    output[i]= 0;
  }
  // some timing:
  bench(reorder_simple);
  bench(reorder_omp)   ;
  bench(copy_simple)   ;
  bench(copy_omp)      ;
}


   % g++ reorder.cpp -o reorder -std=c++11 -O3 -march=native -fopenmp -Wall
   % ./reorder
     reorder_simple, Time taken: 0.0179023 /s
        reorder_omp, Time taken: 0.00349932 /s
        copy_simple, Time taken: 0.00140805 /s
           copy_omp, Time taken: 0.000250205 /s

我想使reorder_omp函数更接近copy_omp函数的速度。检测器可以每秒500帧的速度运行，因此3.5毫秒（0.25毫秒）比0.25毫秒的时间差。

再次编辑：2018年11月21日，代码编写未编译的函数

  //top of file
  #include <fstream>  
  ...
  //just before the end: 
  std::ofstream out;
  out.open("cfunc.c");
  out << "void cfunc( unsigned short * restrict input,\n" <<
         "            unsigned short * restrict output){ \n"; 
  for(int i=0;i<N;i++)
    for(int j=0;j<N;j++)
      out << "output[" << i*N+j << "] = input[" << indices[i*N+j] << "];\n";
  out << "}\n";
  out.close();

在另一台机器上进行测试我从gcc（7.3.0）和clang（6.0.0）都收到了编译器错误。它可以编译并以tcc（0.9.27）运行，但完成速度比循环遍历索引慢。

Answer 1

（评论部分太短）

我会测试以下想法：

维护反向索引表，从而使朴素算法变为：

 for (i = 0; i<n; i++) {
   dest[index[i]] = src[i];
 }

代替天真的算法：

2.1创建临时的配对数组（值，destindex）
```
struct pair {
  int value;
  int destindex;
};
for (i = 0; i < n; i++) {
  pairs[i] = {.value=src[i], .destindex=index[i]};
}
```
2.2使用合并或快速排序按.destindex字段对对数组进行排序

2.3将值从对数组复制到dest数组

此算法中没有随机访问，因此也没有随机访问页面错误。但是，由于大量的线性遍历，我不确定它是否会比幼稚算法更好。

如何优化数组的重新排序？

编辑21/11/2018添加了完整但最小的问题示例

再次编辑：2018年11月21日，代码编写未编译的函数

1 个答案: