Armadilloによる行列乗算のSuper C ++最適化

私はArmadilloを使用して、辺の長さが非常に集中的な行列乗算を行っています。ここで、は最大20以上にすることができます。私が使用しているアルマジロをしてOpenBLAS私は、パフォーマンスの最適化のためのスーパーアルマジロでの乗算の形式主義に問題があることを除いて、並列コアで非常に良い仕事をしているように見える行列乗算、ため。$2^n$$n$

次の形式のループがあるとします。

arma::cx_mat stateMatrix, evolutionMatrix; //armadillo complex matrix type
for(double t = t0; t < t1; t += 1/sampleRate)
{
    ...
    stateMatrix = evolutionMatrix*stateMatrix;
    ...
}

基本的なC ++では、私はここでの問題を見つけることはC ++での新しいオブジェクトに割り当てるということであるcx_mat店にしevolutionMatrix*stateMatrix、その後に新しいオブジェクトをコピーstateMatrixしてoperator=()。これは非常に非効率的です。大きなデータ型の複雑なクラスを返すのは悪い考えだということはよく知られていますよね？

この方法がより効率的であると私が考える方法は、次の形式で乗算を行う関数を使用することです。

void multiply(const cx_mat& mat1, const cx_mat& mat2, cx_mat& output)
{
    ... //multiplication of mat1 and mat2 and then store it in output
}

このようにして、戻り値を持つ巨大なオブジェクトをコピーする必要がなくなり、乗算ごとに出力を再割り当てする必要がなくなります。

質問：Armadilloを使用してBLASの優れたインターフェイスで乗算を実行し、行列オブジェクトを再作成して各操作でそれらをコピーする必要なく効率的にこれを行うには、どうすれば妥協点を見つけることができますか？

これはアルマジロの実装上の問題ではありませんか？

基本的なC ++では、C ++がcx_matの新しいオブジェクトを割り当てて、evolutionMatrix * stateMatrixを格納し、その新しいオブジェクトをoperator =（）を使用してstateMatrixにコピーするという問題があることがわかりました。

テンポラリーを作成しているのは遅いと思うが、それは遅すぎるが、それを行っている理由は間違っていると思う。

Armadilloは、優れたC ++線形代数ライブラリと同様に、式テンプレートを使用して式の遅延評価を実装します。以下のようにあなたは行列積を書き留めときはA*B何も一時は作成されず、代わりに、アルマジロは、（一時的なオブジェクトを作るx）への参照を保持していること AとB、そしてその後、表現のように与えられC = x、行列積が直接結果を格納する計算Cいかなる作成せずに、一時。

また、この最適化を使用して、のような式を処理しますA*B*C*D。ここで、行列のサイズに応じて、特定の乗算の次数は他よりも効率的です。

これはアルマジロの実装上の問題ではありませんか？

Armadilloがこの最適化を実行していない場合、それは開発者に報告する必要があるArmadilloのバグです。

ただし、あなたのケースでは、より重要な別の問題があります。A=B*Cのストレージのような式では、エイリアスまたはがないA場合、入力データは含まれAません。あなたの場合、 出力行列に何かを書き込むと、入力行列の1つも変更されます。BCA = A*B

あなたの提案された機能を与えられても

multiply(const cx_mat&, const cx_mat&, cx_mat&)

その関数は式でどの程度正確に役立ちmultiply(A, B, A)ますか？その関数のほとんどの通常の実装では、バグが発生します。入力データが破損していないことを確認するために、一時ストレージを独自に使用する必要があります。あなたの提案は、Armadilloがすでに行列乗算を実装している方法とほぼ同じですがmultiply(A, B, A)、一時的な割り当てなどの状況を回避するためにおそらく注意が必要だと思います 。

Armadillo がこの最適化を行わない理由の最も可能性の高い説明は、それを行うのは正しくないということです。

最後に、次のように、やりたいことを実行する非常に簡単な方法があります。

cx_mat *A, *Atemp, B;
for (;;) {
  *Atemp = (*A)*B;
  swap(A, Atemp);
}

これは同じです

cx_mat A, B;
for (;;) {
  A = A*B;
}

ただし、反復ごとに1つの一時行列ではなく、1つの一時行列を割り当てます。

@BillGreeneは、根本的な問題を回避する方法として「戻り値の最適化」を示していますが、これは実際にはその半分だけに役立ちます。次の形式のコードがあるとします。

struct ExpensiveObject { ExpensiveObject(); ~ExpensiveObject(); };

ExpensiveObject operator+ (ExpensiveObject &obj1,
                           ExpensiveObject &obj2)
{
   ExpensiveObject tmp;
   ...compute tmp based on obj1 and obj2...
   return tmp;
}

void f() {
  ExpensiveObject o1, o2, o3;
  ...initialize o1, o2...;
  o3 = o1 + o2;
}

素朴なコンパイラは

1. プラス操作の結果を格納するスロットを作成します（一時的なもの）。
2. operator +、
3. operator +（2番目の一時ファイル）内に「tmp」オブジェクトを作成します。
4. tmpを計算する
5. tmpを結果スロットにコピーし、
6. tmpを破壊し、
7. 結果オブジェクトをo3にコピーする
8. 結果オブジェクトを破棄する

戻り値の最適化では、「tmp」オブジェクトと「result」スロットのみを統合できますが、コピーの必要性を取り除くことはできません。そのため、一時ファイルの作成、コピー操作、一時ファイルの破棄が残ります。

これを回避する唯一の方法は、operator +がオブジェクトを返さないことですが、中間クラスのオブジェクトは、に割り当てられたときにExpensiveObject、追加およびコピー操作を実行します。これは、式テンプレートライブラリで一般的に使用されるアプローチです。

Stackoverflow（https://stackoverflow.com/）は、おそらくこの質問のためのより良いディスカッションフォーラムです。しかし、ここに短い答えがあります。

上で説明したように、C ++コンパイラがこの式のコードを生成しているとは思いません。最新のC ++コンパイラーはすべて、「戻り値の最適化」と呼ばれる最適化を実装しています（http://en.wikipedia.org/wiki/Return_value_optimization）。戻り値を最適化すると、の結果evolutionMatrix*stateMatrixはに直接格納されstateMatrixます。コピーは作成されません。

このトピックには明らかにかなりの混乱があり、それがStackoverflowの方が優れたフォーラムになる可能性があると私が提案した理由の1つです。そこには多くのC ++の「言語弁護士」がいますが、ここで私たちのほとんどはCSEに時間を費やしたいと思っています。;-)

バンガース教授の投稿に基づいて、次の簡単な例を作成しました。

#ifndef NDEBUG
#include <iostream>

using namespace std;
#endif

class ExpensiveObject  {
public:
  ExpensiveObject () {
#ifndef NDEBUG
    cout << "ExpensiveObject  constructor called." << endl;
#endif
    v = 0;
  }
  ExpensiveObject (int i) { 
#ifndef NDEBUG
    cout << "ExpensiveObject  constructor(int) called." << endl;
#endif
    v = i; 
  }
  ExpensiveObject (const ExpensiveObject  &a) {
    v = a.v;
#ifndef NDEBUG
    cout << "ExpensiveObject  copy constructor called." << endl;
#endif
  }
  ~ExpensiveObject() {
#ifndef NDEBUG
    cout << "ExpensiveObject  destructor called." << endl;
#endif
  }
  ExpensiveObject  operator=(const ExpensiveObject  &a) {
#ifndef NDEBUG
    cout << "ExpensiveObject  assignment operator called." << endl;
#endif
    if (this != &a) {
      return ExpensiveObject (a);
    }
  }
  void print() const {
#ifndef NDEBUG
    cout << "v=" << v << endl;
#endif
  }
  int getV() const {
    return v;
  }
private:
  int v;
};

ExpensiveObject  operator+(const ExpensiveObject  &a1, const ExpensiveObject  &a2) {
#ifndef NDEBUG
  cout << "ExpensiveObject  operator+ called." << endl;
#endif
  return ExpensiveObject (a1.getV() + a2.getV());
}

int main()
{
  ExpensiveObject  a(2), b(3);
  ExpensiveObject  c = a + b;
#ifndef NDEBUG
  c.print();
#endif
}

最適化モードでコンパイルするときに、出力を出力するためのすべてのコードを完全に削除したかったため、実際よりも複雑に見えます。デバッグオプションでコンパイルしたバージョンを実行すると、次の出力が表示されます。

ExpensiveObject  constructor(int) called.
ExpensiveObject  constructor(int) called.
ExpensiveObject  operator+ called.
ExpensiveObject  constructor(int) called.
v=5
ExpensiveObject  destructor called.
ExpensiveObject  destructor called.
ExpensiveObject  destructor called.

通知に最初のものは、ということです何の一時のみ、B、およびCをconstructed--されていません。デフォルトのコンストラクターと代入演算子は、この例では必要ないため、呼び出されることはありません。

バンガース教授は表現テンプレートについて言及しました。確かに、この最適化手法は、マトリックスクラスライブラリで良好なパフォーマンスを得るために非常に重要です。ただし、オブジェクト式が単にa + bよりも複雑な場合にのみ重要です。たとえば、私のテストが代わりだった場合：

  ExpensiveObject  a(2), b(3), c(9);
  ExpensiveObject  d = a + b + c;

次の出力が得られます。

ExpensiveObject  constructor(int) called.
 ExpensiveObject  constructor(int) called.
 ExpensiveObject  constructor(int) called.
 ExpensiveObject  operator+ called.
 ExpensiveObject  constructor(int) called.
 ExpensiveObject  operator+ called.
 ExpensiveObject  constructor(int) called.
 ExpensiveObject  destructor called.
 v=14
 ExpensiveObject  destructor called.
 ExpensiveObject  destructor called.
 ExpensiveObject  destructor called.
 ExpensiveObject  destructor called.

このケースは、一時的な構成（コンストラクターへの5つの呼び出しと演算子+の2つの呼び出し）の望ましくない構成を示しています。式テンプレート（このフォーラムの範囲をはるかに超えるトピック）の適切な使用は、これを一時的に防止します。（非常にやる気のある人のために、式テンプレートの特に読みやすい議論はhttp://www.amazon.com/C-Templates-The-Complete-Guide/dp/0201734842の第18章にあります）。

最後に、コンパイラが実際に行っていることの実際の「証明」は、コンパイラによって出力されたアセンブリコードを調べることから得られます。最初の例では、最適化モードでコンパイルした場合、このコードは驚くほど単純です。すべての関数呼び出しは最適化され、アセンブリコードは基本的に2を1つのレジスタに、3を1つのレジスタにロードし、それらを追加します。

$\mathcal{O}(n^{2.8})$$\mathcal{O}(n^2)$$n$

つまり、コピーに膨大な定数が発生しない限り、実際にはそれほどフェッチされません。コピー付きのバージョンは、別の点ではるかにコストがかかるためです。それは、より多くのメモリが必要です。したがって、ハードディスクとの間でスワップする必要がある場合は、コピーが実際にボトルネックになる可能性があります。ただし、自分で何もコピーしない場合でも、強力に並列化されたアルゴリズムは、独自のコピーをいくつか実行する場合があります。実際、各ステップでメモリが多すぎないことを確認する唯一の方法は、乗算をの列stateMatrixに分割することです。そのため、一度に小さな乗​​算のみが実行されます。たとえば、次のように定義できます。

class HChunkMatrix // optimised for destructive left-multiplication updates
{
  std::vector<arma::cx_mat> colChunks; // e.g. for an m×n matrix,
                                      //  use √n chunks, each an m×√n matrix
 public:
  ...

  HChunkMatrix& operator *= (const arma::cx_mat& lhMult) {
    for (&colChunk: colChunks) {
      colChunk = lhMult * colChunk;
    }
    return *this;
  }
}

また、そもそもそれstateMatrixを1つに発展させる必要があるかどうかについても検討する必要があります。基本的には、独立してn状態キットの時間発展が必要な場合、それらを1つずつ進化させることもできます。これにより、メモリコストが大幅に削減されます。特にevolutionMatrixがsparseの場合、必ず確認する必要があります。これは基本的にはハミルトニアンに過ぎませんね。ハミルトニアンは、しばしばスパースまたはほぼスパースです。

_{$\mathcal{O}(n^{2.38})$}

最新のC ++には、「移動コンストラクター」と「右辺値参照」を使用することによる問題の解決策があります。

「移動コンストラクター」は、クラスのコンストラクターです。たとえば、マトリックスクラスは、同じクラスの別のインスタンスを受け取り、データを他のインスタンスから新しいインスタンスに移動して、元のインスタンスを空のままにします。通常、行列オブジェクトには、サイズとデータへのポインターの2つの数値があります。通常のコンストラクターがデータを複製する場合、移動コンストラクターは2つの数値とポインターのみをコピーするため、これは非常に高速です。

通常の "matrix＆"の代わりに "matrix &&"のように書かれた "rvalue参照"が一時変数に使用されます。行列の乗算を行列&&を返すものとして宣言します。それを行うことにより、コンパイラーは、非常に安価なmoveコンストラクターを使用して、それを呼び出す関数から結果を取得するようにします。したがって、result =（a + b）*（c + d）のような式（a、b、c、dは巨大な行列オブジェクト）は、コピーせずに発生します。

「右辺値参照と移動コンストラクター」をグーグル検索すると、例とチュートリアルが見つかります。

$v'*M*M*M*M*M$$M*M*M*M*M*v$

次に、OpenBLASにはアーキテクチャ固有の最適化のより大きなコレクションがあるので、Eigenがあなたにとって有利な場合とそうでない場合があります。残念ながら、線形代数ライブラリーは非常に優れているため、パフォーマンスの「最後の10％」を目指して戦うときに、他のライブラリーを考慮する必要すらありません。ラッパーは100％のソリューションではありません。それらのほとんど（すべて？）は、この方法で計算をマージするeigenの機能を利用できません。