OpenCL 增强单work-item kernel性能策略

1、基于反馈的Optimization Report解决单个Work-item的Kernel相关性

　　在许多情况下，将OpenCL™应用程序设计为单个工作项内核就足以在不执行其他优化步骤的情况下最大化性能。

　　建议采用以下优化单个work-item kernel的选项来按照实用性顺序解决单个work-item kernel循环携带的依赖性：

　　　　removal，relaxation，simplification，transfer to local memory。

(1) Removing Loop-Carried Dependency

　　根据优化报告的反馈，可以通过实现更简单的内存访问的方式来消除循环携带的依赖关系。

优化前：

  #define N 128

  __kernel void unoptimized (__global int * restrict A,
                             __global int * restrict B,
                             __global int* restrict result)
  {
    int sum = ;

    for (unsigned i = ; i < N; i++) {
     for (unsigned j = ; j < N; j++) {
       sum += A[i*N+j];
     }
     sum += B[i];
   }

   * result = sum;
 }

优化后：

  #define N 128

  __kernel void optimized (__global int * restrict A,
                           __global int * restrict B,
                           __global int * restrict result)
  {
    int sum = ;

    for (unsigned i = ; i < N; i++) {
     // Step 1: Definition
     int sum2 = ;

     // Step 2: Accumulation of array A values for one outer loop iteration
     for (unsigned j = ; j < N; j++) {
       sum2 += A[i*N+j];
     }

     // Step 3: Addition of array B value for an outer loop iteration
     sum += sum2;
     sum += B[i];
   }

   * result = sum;
 }

(2) Relaxing Loop-Carried Dependency

　　根据优化报告的反馈，可以通过增加依赖距离的方式来relax缓解循环携带的依赖关系。

优化前：

  #define N 128

  __kernel void unoptimized (__global float * restrict A,
                             __global float * restrict result)
  {
    float mul = 1.0f;

    for (unsigned i = ; i < N; i++)
      mul *= A[i];

   * result = mul;
 }

优化后：

  #define N 128
  #define M 8

  __kernel void optimized (__global float * restrict A,
                           __global float * restrict result)
  {
    float mul = 1.0f;

    // Step 1: Declare multiple copies of variable mul
   float mul_copies[M];

   // Step 2: Initialize all copies
   for (unsigned i = ; i < M; i++)
     mul_copies[i] = 1.0f;

   for (unsigned i = ; i < N; i++) {
     // Step 3: Perform multiplication on the last copy
     float cur = mul_copies[M-] * A[i];

     // Step 4a: Shift copies
     #pragma unroll
     for (unsigned j = M-; j > ; j--)
       mul_copies[j] = mul_copies[j-];

     // Step 4b: Insert updated copy at the beginning
     mul_copies[] = cur;
   }

   // Step 5: Perform reduction on copies
   #pragma unroll
   for (unsigned i = ; i < M; i++)
     mul *= mul_copies[i];

   * result = mul;
 }

(3) Transferring Loop-Carried Dependency to Local Memory

　　对于不能消除的循环携带的依赖关系，可以通过将具有循环依赖的数组从全局内存global memory移动到local memory的方式来改进循环的启动间隔（initiation interval, II）。

优化前：

 #define N 128

 __kernel void unoptimized( __global int* restrict A )
 {
     for (unsigned i = ; i < N; i++)
           A[N-i] = A[i];
 }     

优化后：

  #define N 128

  __kernel void optimized( __global int* restrict A )
  {
      int B[N];

      for (unsigned i = ; i < N; i++)
          B[i] = A[i];

     for (unsigned i = ; i < N; i++)
         B[N-i] = B[i];

     for (unsigned i = ; i < N; i++)
         A[i] = B[i];
 }

(4) Relaxing Loop-Carried Dependency by Inferring Shift Registers

　　为了使SDK能够有效地处理执行双精度浮点运算的单个work-item kernels，可以通过推断移位寄存器的方式移除循环携带的依赖性。

优化前：

  __kernel void double_add_1 (__global double *arr,
                              int N,
                              __global double *result)
  {
    double temp_sum = ;

    for (int i = ; i < N; ++i)
    {
        temp_sum += arr[i];
   }

   *result = temp_sum;
 }

优化后：

  //Shift register size must be statically determinable
  #define II_CYCLES 12

  __kernel void double_add_2 (__global double *arr,
                              int N,
                              __global double *result)
  {
      //Create shift register with II_CYCLE+1 elements
      double shift_reg[II_CYCLES+];

     //Initialize all elements of the register to 0
     for (int i = ; i < II_CYCLES + ; i++)
     {
         shift_reg[i] = ;
     }

     //Iterate through every element of input array
     for(int i = ; i < N; ++i)
     {
         //Load ith element into end of shift register
         //if N > II_CYCLE, add to shift_reg[0] to preserve values
         shift_reg[II_CYCLES] = shift_reg[] + arr[i];

         #pragma unroll
         //Shift every element of shift register
         for(int j = ; j < II_CYCLES; ++j)
         {
             shift_reg[j] = shift_reg[j + ];
         }
     }

     //Sum every element of shift register
     double temp_sum = ;

     #pragma unroll
     for(int i = ; i < II_CYCLES; ++i)
     {
         temp_sum += shift_reg[i];
     }

     *result = temp_sum;
 }

(5) Removing Loop-Carried Dependencies Cause by Accesses to Memory Arrays

　　在单个work-item的kernel中包含ivdep pragma以保证堆内存array的访问不会导致循环携带的依赖性。

　　如果对循环中的内存阵列的所有访问都不会导致循环携带的依赖性，在内核代码中的循环之前添加#pragma ivdep。

// no loop-carried dependencies for A and B array accesses
#pragma ivdep
for (int i = ; i < N; i++) {
    A[i] = A[i - X[i]];
    B[i] = B[i - Y[i]];
}

　　要指定对循环内特定内存数组的访问不会导致循环携带的依赖关系，在内核代码中的循环之前添加#pragma ivdep arrayarray_name）。

　　ivdep pragma指定的数组必须是local / private内存数组，或者是指向global/local/private内存存储的指针变量。 如果指定的数组是指针，则ivdep pragma也适用于所有可能带有指定指针别名的数组。

　　ivdep pragma指示指定的数组也可以是struct的数组或指针成员。

// No loop-carried dependencies for A array accesses
// The offline compiler will insert hardware that reinforces dependency constraints for B
#pragma ivdep array(A)
for (int i = ; i < N; i++) {
    A[i] = A[i - X[i]];
    B[i] = B[i - Y[i]];
}

// No loop-carried dependencies for array A inside struct
#pragma ivdep array(S.A)
for (int i = ; i < N; i++) {
    S.A[i] = S.A[i - X[i]];
}

// No loop-carried dependencies for array A inside the struct pointed by S
#pragma ivdep array(S->X[2][3].A)
for (int i = ; i < N; i++) {
    S->X[][].A[i] = S.A[i - X[i]];
}

// No loop-carried dependencies for A and B because ptr aliases
// with both arrays
int *ptr = select ? A : B;
#pragma ivdep array(ptr)
for (int i = ; i < N; i++) {
    A[i] = A[i - X[i]];
    B[i] = B[i - Y[i]];
}

// No loop-carried dependencies for A because ptr only aliases with A
int *ptr = &A[];
#pragma ivdep array(ptr)
for (int i = ; i < N; i++) {
    A[i] = A[i - X[i]];
    B[i] = B[i - Y[i]];
}

2、Single work-item kernel的设计技巧

　　避免指针混淆。使用restrict关键词。

　　创建格式正确的循环。退出条件与整数进行比较，且每次迭代的增量为1。格式正确的嵌套循环也对最大化kernel性能有帮助。

　　最小化loop-carried循环携带依赖遵循以下原则：

　　　　避免使用指针算数；

　　　　声明简单的数组索引；

　　　　尽可能在kernel中使用恒定边界的循环。

　　避免复杂的循环退出条件；

　　将嵌套循环转换为单循环；

　　避免条件循环； 避免if else中包含循环，尽量转换为在循环中包含if else。

　　在尽可能深的范围内声明变量。