web-dev-qa-db-ja.com

プリフェッチの例？

誰でも、GCCで__builtin_prefetch（または一般的にはasm命令prefetcht0）を使用してパフォーマンスを大幅に向上させる例や例へのリンクを提供できますか？特に、次の基準を満たすように例を示します。

  1. これは、シンプルで小さな自己完結型の例です。
  2. __builtin_prefetch命令を削除すると、パフォーマンスが低下します。
  3. __builtin_prefetch命令を対応するメモリアクセスに置き換えると、パフォーマンスが低下します。

つまり、それなしでは管理できなかった最適化を実行する__builtin_prefetchを示す最も短い例が必要です。

gccoptimizationassemblyprefetch
60
Shaun Harker

これは、より大きなプロジェクトから引き出した実際のコードです。 （申し訳ありませんが、プリフェッチからの顕著な高速化は、私が見つけることができる最も短いものです。）このコードは、非常に大きなデータの転置を実行します。

この例では、SSEプリフェッチ命令を使用します。これは、GCCが発行するものと同じ場合があります。

この例を実行するには、これをx64用にコンパイルし、4GB以上のメモリが必要です。より小さなデータサイズで実行できますが、時間がかかりすぎます。

#include <iostream>
using std::cout;
using std::endl;

#include <emmintrin.h>
#include <malloc.h>
#include <time.h>
#include <string.h>

#define ENABLE_PREFETCH


#define f_vector    __m128d
#define i_ptr       size_t
inline void swap_block(f_vector *A,f_vector *B,i_ptr L){
    //  To be super-optimized later.

    f_vector *stop = A + L;

    do{
        f_vector tmpA = *A;
        f_vector tmpB = *B;
        *A++ = tmpB;
        *B++ = tmpA;
    }while (A < stop);
}
void transpose_even(f_vector *T,i_ptr block,i_ptr x){
    //  Transposes T.
    //  T contains x columns and x rows.
    //  Each unit is of size (block * sizeof(f_vector)) bytes.

    //Conditions:
    //  - 0 < block
    //  - 1 < x

    i_ptr row_size = block * x;
    i_ptr iter_size = row_size + block;

    //  End of entire matrix.
    f_vector *stop_T = T + row_size * x;
    f_vector *end = stop_T - row_size;

    //  Iterate each row.
    f_vector *y_iter = T;
    do{
        //  Iterate each column.
        f_vector *ptr_x = y_iter + block;
        f_vector *ptr_y = y_iter + row_size;

        do{

#ifdef ENABLE_PREFETCH
            _mm_prefetch((char*)(ptr_y + row_size),_MM_HINT_T0);
#endif

            swap_block(ptr_x,ptr_y,block);

            ptr_x += block;
            ptr_y += row_size;
        }while (ptr_y < stop_T);

        y_iter += iter_size;
    }while (y_iter < end);
}
int main(){

    i_ptr dimension = 4096;
    i_ptr block = 16;

    i_ptr words = block * dimension * dimension;
    i_ptr bytes = words * sizeof(f_vector);

    cout << "bytes = " << bytes << endl;
//    system("pause");

    f_vector *T = (f_vector*)_mm_malloc(bytes,16);
    if (T == NULL){
        cout << "Memory Allocation Failure" << endl;
        system("pause");
        exit(1);
    }
    memset(T,0,bytes);

    //  Perform in-place data transpose
    cout << "Starting Data Transpose...   ";
    clock_t start = clock();
    transpose_even(T,block,dimension);
    clock_t end = clock();

    cout << "Done" << endl;
    cout << "Time: " << (double)(end - start) / CLOCKS_PER_SEC << " seconds" << endl;

    _mm_free(T);
    system("pause");
}

ENABLE_PREFETCHを有効にして実行すると、これが出力になります。

bytes = 4294967296
Starting Data Transpose...   Done
Time: 0.725 seconds
Press any key to continue . . .

ENABLE_PREFETCHを無効にして実行すると、これが出力になります。

bytes = 4294967296
Starting Data Transpose...   Done
Time: 0.822 seconds
Press any key to continue . . .

そのため、プリフェッチの速度が13％向上します。

編集：

以下にいくつかの結果を示します。

Operating System: Windows 7 Professional/Ultimate
Compiler: Visual Studio 2010 SP1
Compile Mode: x64 Release

Intel Core i7 860 @ 2.8 GHz, 8 GB DDR3 @ 1333 MHz
Prefetch   : 0.868
No Prefetch: 0.960

Intel Core i7 920 @ 3.5 GHz, 12 GB DDR3 @ 1333 MHz
Prefetch   : 0.725
No Prefetch: 0.822

Intel Core i7 2600K @ 4.6 GHz, 16 GB DDR3 @ 1333 MHz
Prefetch   : 0.718
No Prefetch: 0.796

2 x Intel Xeon X5482 @ 3.2 GHz, 64 GB DDR2 @ 800 MHz
Prefetch   : 2.273
No Prefetch: 2.666
62
Mysticial

バイナリ検索は、明示的なプリフェッチの恩恵を受ける単純な例です。バイナリ検索のアクセスパターンは、ハードウェアプリフェッチャーにとってはかなりランダムに見えるため、フェッチする対象を正確に予測する可能性はほとんどありません。

この例では、現在の反復の次のループ反復の2つの「中間」位置をプリフェッチします。プリフェッチの1つはおそらく使用されませんが、もう1つは使用されます（これが最後の反復でない限り）。

 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>

 int binarySearch(int *array, int number_of_elements, int key) {
         int low = 0, high = number_of_elements-1, mid;
         while(low <= high) {
                 mid = (low + high)/2;
            #ifdef DO_PREFETCH
            // low path
            __builtin_prefetch (&array[(mid + 1 + high)/2], 0, 1);
            // high path
            __builtin_prefetch (&array[(low + mid - 1)/2], 0, 1);
            #endif

                 if(array[mid] < key)
                         low = mid + 1; 
                 else if(array[mid] == key)
                         return mid;
                 else if(array[mid] > key)
                         high = mid-1;
         }
         return -1;
 }
 int main() {
     int SIZE = 1024*1024*512;
     int *array =  malloc(SIZE*sizeof(int));
     for (int i=0;i<SIZE;i++){
       array[i] = i;
     }
     int NUM_LOOKUPS = 1024*1024*8;
     srand(time(NULL));
     int *lookups = malloc(NUM_LOOKUPS * sizeof(int));
     for (int i=0;i<NUM_LOOKUPS;i++){
       lookups[i] = Rand() % SIZE;
     }
     for (int i=0;i<NUM_LOOKUPS;i++){
       int result = binarySearch(array, SIZE, lookups[i]);
     }
     free(array);
     free(lookups);
 }

DO_PREFETCHを有効にしてこの例をコンパイルして実行すると、実行時間が20％短縮されます。

 $ gcc c-binarysearch.c -DDO_PREFETCH -o with-prefetch -std=c11 -O3
 $ gcc c-binarysearch.c -o no-prefetch -std=c11 -O3

 $ perf stat -e L1-dcache-load-misses,L1-dcache-loads ./with-prefetch 

  Performance counter stats for './with-prefetch':

    356,675,702      L1-dcache-load-misses     #   41.39% of all L1-dcache hits  
   861,807,382      L1-dcache-loads                                             

   8.787467487 seconds time elapsed

 $ perf stat -e L1-dcache-load-misses,L1-dcache-loads ./no-prefetch 

 Performance counter stats for './no-prefetch':

   382,423,177      L1-dcache-load-misses     #   97.36% of all L1-dcache hits  
   392,799,791      L1-dcache-loads                                             

  11.376439030 seconds time elapsed

プリフェッチバージョンでは2倍のL1キャッシュロードを実行していることに注意してください。実際にはより多くの作業を行っていますが、メモリアクセスパターンはパイプラインにより適しています。これもトレードオフを示しています。このコードブロックは単独で高速に実行されますが、大量のジャンクをキャッシュにロードしているため、アプリケーションの他の部分により大きな負荷がかかる可能性があります。

34
James Scriven

@JamesScrivenと@Mysticalの優れた回答から多くのことを学びました。ただし、それらの例は控えめなブーストのみを提供します-この回答の目的は、プリフェッチがより大きな影響を与える（多少人工的なことを告白しなければならない）例（マシンの約4倍）を提示することです。

最新のアーキテクチャには、CPU速度、メモリ帯域幅、メモリ遅延という3つのボトルネックがあります。プリフェッチとは、メモリアクセスの遅延を減らすことです。

レイテンシがX計算ステップに対応する完璧なシナリオでは、X計算ステップでアクセスするメモリを通知するOracleがあり、このデータのプリフェッチが開始され、すぐに到着します時間Xの計算ステップ。

多くのアルゴリズムについて、私たちは（ほぼ）この完璧な世界にいます。単純なforループの場合、Xステップ後に必要なデータを簡単に予測できます。ここでは、アウトオブオーダー実行やその他のハードウェアトリックが非常にうまく機能しており、レイテンシをほぼ完全に隠しています。

それが、@ Mysticalの例にそれほど控えめな改善がある理由です。プリフェッチャーはすでにかなり良いです-改善の余地はほとんどありません。タスクもメモリにバインドされているため、おそらく帯域幅はあまり残っていません-制限要因になる可能性があります。私のマシンでは、せいぜい8％程度の改善しか見られませんでした。

@JamesScrivenの例からの重要な洞察：現在のデータがメモリからフェッチされる前に、私たちもCPUも次のアクセスアドレスを知りません-この依存関係は非常に重要です、そうでなければ、順不同の実行は先読みにつながりますハードウェアはデータをプリフェッチできます。ただし、1つのステップしか推測できないため、それほど大きな可能性はありません。マシンで40％以上を取得できませんでした。

そこで、Xステップでアクセスされるアドレスを知るように競争をリグし、データを準備しますが、まだアクセスされていないデータへの依存関係のためにハードウェアがそれを見つけることを不可能にします（最後にプログラム全体を参照してください）答えの）：

//making random accesses to memory:
unsigned int next(unsigned int current){
   return (current*10001+328)%SIZE;
}

//the actual work is happening here
void operator()(){

    //set up the Oracle - let see it in the future Oracle_offset steps
    unsigned int prefetch_index=0;
    for(int i=0;i<Oracle_offset;i++)
        prefetch_index=next(prefetch_index);

    unsigned int index=0;
    for(int i=0;i<STEP_CNT;i++){
        //use Oracle and prefetch memory block used in a future iteration
        if(prefetch){
            __builtin_prefetch(mem.data()+prefetch_index,0,1);    
        }

        //actual work, the less the better
        result+=mem[index];

        //prepare next iteration
        prefetch_index=next(prefetch_index);  #update Oracle
        index=next(mem[index]);               #dependency on `mem[index]` is VERY important to prevent hardware from predicting future
    }
}

いくつかのコメント：

  1. データは、Oracleが常に正しい方法で準備されます。
  2. 驚くべきことに、CPUにバインドされたタスクが少ないほど高速化が大きくなります。レイテンシをほぼ完全に隠すことができるため、高速化はCPU-time+original-latency-time/CPU-timeです。

リードのコンパイルと実行：

>>> g++ -std=c++11 prefetch_demo.cpp -O3 -o prefetch_demo
>>> ./prefetch_demo
#preloops   time no prefetch    time prefetch   factor
...
7   1.0711102260000001  0.230566831 4.6455521002498408
8   1.0511602149999999  0.22651144600000001 4.6406494398521474
9   1.049024333 0.22841439299999999 4.5926367389641687
....

4〜5のスピードアップに。

prefetch_demp.cppのリスト：

//prefetch_demo.cpp

#include <vector>
#include <iostream>
#include <iomanip>
#include <chrono>

const int SIZE=1024*1024*1;
const int STEP_CNT=1024*1024*10;

unsigned int next(unsigned int current){
   return (current*10001+328)%SIZE;
}


template<bool prefetch>
struct Worker{
   std::vector<int> mem;

   double result;
   int Oracle_offset;

   void operator()(){
        unsigned int prefetch_index=0;
        for(int i=0;i<Oracle_offset;i++)
            prefetch_index=next(prefetch_index);

        unsigned int index=0;
        for(int i=0;i<STEP_CNT;i++){
            //prefetch memory block used in a future iteration
            if(prefetch){
                __builtin_prefetch(mem.data()+prefetch_index,0,1);    
            }
            //actual work:
            result+=mem[index];

            //prepare next iteration
            prefetch_index=next(prefetch_index);
            index=next(mem[index]);
        }
   }

   Worker(std::vector<int> &mem_):
       mem(mem_), result(0.0), Oracle_offset(0)
   {}
};

template <typename Worker>
    double timeit(Worker &worker){
    auto begin = std::chrono::high_resolution_clock::now();
    worker();
    auto end = std::chrono::high_resolution_clock::now();
    return std::chrono::duration_cast<std::chrono::nanoseconds>(end-begin).count()/1e9;
}


 int main() {
     //set up the data in special way!
     std::vector<int> keys(SIZE);
     for (int i=0;i<SIZE;i++){
       keys[i] = i;
     }

     Worker<false> without_prefetch(keys);
     Worker<true> with_prefetch(keys);

     std::cout<<"#preloops\ttime no prefetch\ttime prefetch\tfactor\n";
     std::cout<<std::setprecision(17);

     for(int i=0;i<20;i++){
         //let Oracle see i steps in the future:
         without_prefetch.Oracle_offset=i;
         with_prefetch.Oracle_offset=i;

         //calculate:
         double time_with_prefetch=timeit(with_prefetch);
         double time_no_prefetch=timeit(without_prefetch);

         std::cout<<i<<"\t"
                  <<time_no_prefetch<<"\t"
                  <<time_with_prefetch<<"\t"
                  <<(time_no_prefetch/time_with_prefetch)<<"\n";
     }

 }
3
ead

ドキュメント から：

      for (i = 0; i < n; i++)
        {
          a[i] = a[i] + b[i];
          __builtin_prefetch (&a[i+j], 1, 1);
          __builtin_prefetch (&b[i+j], 0, 1);
          /* ... */
        }
0
wallyk

プリフェッチデータはキャッシュラインサイズに最適化できます。これは、ほとんどの最新の64ビットプロセッサでは64バイトで、たとえば1つの命令でuint32_t [16]をプリロードします。

たとえば、ArmV8で、メモリポインターをuint32_t 4x4マトリックスベクトル（サイズは64バイト）にキャストする実験を通じて、データの半分しかロードしていないのに8ずつインクリメントする必要がある前に必要な命令が半分になることを発見しました私の理解では、完全なキャッシュラインを取得することでした。

Uint32_t [32]元のコード例をプリフェッチしています...

int addrindex = &B[0];
    __builtin_prefetch(&V[addrindex]);
    __builtin_prefetch(&V[addrindex + 8]);
    __builtin_prefetch(&V[addrindex + 16]);
    __builtin_prefetch(&V[addrindex + 24]);

後...

int addrindex = &B[0];
__builtin_prefetch((uint32x4x4_t *) &V[addrindex]);
__builtin_prefetch((uint32x4x4_t *) &V[addrindex + 16]);

何らかの理由で、アドレスインデックス/オフセットのintデータ型がパフォーマンスを向上させました。 Cortex-a53のGCC 8でテスト済み。他のアーキテクチャで同等の64バイトベクトルを使用すると、私の場合のようにすべてのデータをプリフェッチしていないことがわかった場合、同じパフォーマンスが向上する可能性があります。 100万回の反復ループを持つアプリケーションでは、これを行うだけでパフォーマンスが5％向上しました。改善のためのさらなる要件がありました。

128メガバイトの「V」メモリ割り当てを64バイトに揃える必要がありました。

uint32_t *V __attribute__((__aligned__(64))) = (uint32_t *)(((uintptr_t)(__builtin_assume_aligned((unsigned char*)aligned_alloc(64,size), 64)) + 63) & ~ (uintptr_t)(63));

また、Neon Intrinsicsの代わりにC演算子を使用する必要がありました。通常のデータ型ポインターが必要なためです（私の場合はuint32_t *）それ以外の場合、新しい組み込みプリフェッチメソッドのパフォーマンスが低下していました。

私の実世界の例は https://github.com/rollmeister/veriumMiner/blob/main/algo/scrypt.c にあり、scrypt_core（）とその内部関数はすべて簡単です。読んだ。ハードワークはGCC8によって行われます。パフォーマンスの全体的な改善は25％でした。

0
Rauli Kumpulainen