インテル® グラフィックス・テクノロジーにおけるベクトル化

Crossfade の例

下記のコードは、2 つのイメージをマージする非常に単純なイメージフィルターです。平凡なスカラーコードに 2 つのプラグマを追加しています。

bool CrossFade::execute_offload (int do_offload)
{  
   //ここでは、次の理由から、オフロードで使用される "this" オブジェクト・
   // メンバーの一時コピーを作成します。
   // - ポインター型のメンバー: オフロード境界でポインターのマーシャリングは
   // サポートされていないため、正しく動作しません。
   // ターゲットは CPU 形式のポインター値をどう扱うべきか判断できません。
   // - すべてのオブジェクト・メンバー: 効率が悪いため、ターゲットで
   // 二重の間接参照は行うべきではありません。
   unsigned char * inputArray1 = m_inputArray1, * inputArray2 = m_inputArray2,
   * outputArray = m_outputArray;
   int arrayWidth = m_arrayWidth, arrayHeight = m_arrayHeight, arraySize = m_arraySize;

   unsigned a1 = 256 - m_blendFactor;
   unsigned a2 = m_blendFactor;

   // offload プラグマは、共有 (またはコピー) されるデータをすべて
   // リストします。offload プラグマには必須の並列ループが続きます。
   // これは _Cilk_for または配列表記文で表現され、後続のループが並列ループであり、
   // ターゲットで並列化される必要があることを示します。
   #pragma offload target(gfx) if (do_offload) \
     pin(inputArray1, inputArray2, outputArray: length(arraySize))
   _Cilk_for (int i=0; i<arraySize; i++){
     outputArray[i] = (inputArray1[i] * a1 + inputArray2[i] * a2) >> 8;
   }
     return true;
}

タイルを使用した行列乗算の例

このコードは、データ並列を簡潔に表現するため明示的なタイルと配列表記を使用した行列乗算コードです。

bool MatmultLocalsAN::execute_offload(int do_offload)
{
      // 上の例と同様に、"this" オブジェクト・メンバーの一時コピーを
      // 作成します。
      int m = m_height, n = m_width, k = m_common;
      float (* A)[k] = (float (*)[])m_matA;
      float (* B)[n] = (float (*)[])m_matB;
      float (* C)[n] = (float (*)[])m_matC;

      // A、B、C は配列へのポインターですが、長さはポイント先の
      // 配列のサイズ単位ではなく、ポイント先の配列の要素で
      // 指定されます。
      #pragma offload target(gfx) if (do_offload) \
            pin(A: length(m*k)), pin(B: length(k*n)), pin(C: length(m*n))
      // 完全な入れ子構造の並列ループはコンパイラーにより結合できます。
      _Cilk_for (int r = 0; r < m; r += TILE_m) {
         _Cilk_for (int c = 0; c < n; c += TILE_n) {
         // これらの配列はインテル® グラフィックス・
         // テクノロジー・レジスター・ファイル (GRF) で割り当てられ、
         // 非常に効率良いコードになります。
         float atile[TILE_m][TILE_k], btile[TILE_n], ctile[TILE_m][TILE_n];
         // ctile を初期化する配列表記構文。
         // GRF へ直接アクセスできるようにアンロールする
         // 一連のベクトル操作を行います。
         #pragma unroll
         ctile[:][:] = 0.0f;
         for (int t = 0; t < k; t += TILE_k) {
            // 一連のベクトルのロードを行います。
            #pragma unroll
            atile[:][:] = A[r:TILE_m][t:TILE_k];
            // GRF へ直接アクセスできるようにアンロールします。
            #pragma unroll
 
            for (int rc = 0; rc < TILE_k; rc++) {
               // ベクトルのロードを行います。
               btile[:] = B[t+rc][c:TILE_n];
               #pragma unroll
               for (int rt = 0; rt < TILE_m; rt++) {
                  // ベクトル演算を行います。
                  ctile[rt][:] += atile[rt][rc] * btile[:];
               }
            }
         }
         // 一連のベクトルのストアを行います。
         #pragma unroll
         C[r:TILE_m][c:TILE_n] = ctile[:][:];
      }
   }
      return true;
}

次の例は、#pragma simd とベクトル関数の linear および uniform 引数の使用方法を示しています。

__declspec(target(gfx))
__declspec(vector(uniform(in1), linear(i)))
// ポインター型の in1 引数は uniform として定義されています。
// in1 はベクトル関数で配列全体にアクセスできます。
// i は linear として宣言されているため、コンパイラーはより
// 効率的なコードを生成できます。
// in2v と戻り値は整数型のベクトルです。
int vfunction(int * in1, int i, int in2v)
{
    return in1[i - 1] + in2v * in1[i] + in1[i + 1];
}

int main (int argc, char* argv) 
{
    const int size = 4096;
    const int chunkSize = 32;
    const int padding = chunkSize;
    int in1[size], in2[size], out[size];

    // 初期値
    in1[:] = __sec_implicit_index(0);
    in2[:] = size - __sec_implicit_index(0);

    #pragma offload target(gfx) 
    _Cilk_for (int i = padding; i < size - padding; i+=chunkSize)
    {
        #pragma simd
        for (int j = 0; j < chunkSize; j++)
            out[i + j] = vfunction(in1, i + j, in2[i + j]);
    }

    // 以降で出力配列の使用または出力を行います。
    return 0;
}