C++  volatile調査。局所的な最適化阻止

#今回の目的
例えば 他のデバイスが非同期でフラグを変えるのを待つ場合に
コンパイラの最適化によって、望んだ処理が消える可能性がある

その場合に volatileを使うが、そのあたりを調査します


#問題コード
まず簡単な例。flagが初期値0で、0以外の値に変わると
worker!!
と出力し、終了する。
別スレッドで 5秒後にflag=1 に設定するので５秒後に終了するはずのプログラム

（下記に理由を書きますが　本来はスレッドの同期にvolatileを使うのは間違いで、処理系によっては正しく動作できません。今回はそのあたりは無視しています）

```cpp:
#include <iostream>
#include <thread>


int flag = 0;

void worker() {
    while( flag == 0){
    }
    std::cout << "worker!! \n";
    
}

auto main(int argc, const char * argv[]) -> int {
    std::cout << "start\n";

    
    std::thread th(worker);
    
    std::this_thread::sleep_for(std::chrono::seconds(5));
    flag = 1;
    
    th.join();
    
    
    return 0;
};
```

今回 Windowsマシンが調子悪いので Xcode6.1 で実行してみました。

debugビルドだと 5秒後に worker!! が出力されプログラムが終了しますが
releaseビルドだと無限ループになりました

コンパイラの最適化次第では　releaseでも正しく動く事もありますが
Xcode6.1の 逆アセンブラを比較します
わかりやすく該当部分のみ抜粋


```:debugビルド
0x100001170:  pushq  %rbp
0x100001171:  movq   %rsp, %rbp
0x100001174:  subq   $0x10, %rsp
0x100001178:  jmp    0x10000117d               ; worker() + 13 at main.cpp:16
0x10000117d:  cmpl   $0x0, 0x1fa9(%rip)        ; (void *)0x0000000000007fff
0x100001187:  jne    0x100001192               ; worker() + 34 at main.cpp:20
0x10000118d:  jmp    0x10000117d               ; worker() + 13 at main.cpp:16
0x100001192:  movq   0x1e7f(%rip), %rdi        ; (void *)0x00007fff7a3302f8: std::__1::cout
0x100001199:  leaq   0x1d44(%rip), %rsi        ; "worker!! \n"
0x1000011a0:  callq  0x100002bd8               ; symbol stub for: std::__1::basic_ostream<char, std::__1::char_traits<char> >& std::__1::operator<<<std::__1::char_traits<char> >(std::__1::basic_ostream<char, std::__1::char_traits<char> >&, char const*)
0x1000011a5:  movq   %rax, -0x8(%rbp)
0x1000011a9:  addq   $0x10, %rsp
0x1000011ad:  popq   %rbp
0x1000011ae:  retq   
```

AT&Tシンタックスで読むの苦手ですが・・
0x10000117d:  cmpl   $0x0, 0x1fa9(%rip)        ; (void *)0x0000000000007fff
0x100001187:  jne    0x100001192               ; worker() + 34 at main.cpp:20
で、flagの値が0かどうかチェックし　0でなければループを抜けています

0の場合は
0x10000118d:  jmp    0x10000117d               ; worker() + 13 at　main.cpp:16
で、再びflagの値をチェックしています
ので、別スレッドでflagの値が変更された場合 上手く動きますね
（スレッド間のキャッシュ同期問題は 今回考えてません　大事な事なのでry）


問題の release版

```:releaseビルド
0x100000770:  pushq  %rbp
0x100000771:  movq   %rsp, %rbp
0x100000774:  cmpl   $0x0, 0x975(%rip)         ; (void *)0x0000000000000000
0x10000077b:  sete   %al
0x10000077e:  testb  $0x1, %al
0x100000780:  movb   $0x1, %al
0x100000782:  jne    0x10000077e               ; worker() + 14 at main.cpp:27
0x100000784:  movq   0x885(%rip), %rdi         ; (void *)0x00007fff7a3302f8: std::__1::cout
0x10000078b:  leaq   0x766(%rip), %rsi         ; "worker!! \n"
0x100000792:  movl   $0xa, %edx
0x100000797:  popq   %rbp
0x100000798:  jmp    0x10000097e               ; std::__1::basic_ostream<char, std::__1::char_traits<char> >& std::__1::__put_character_sequence<char, std::__1::char_traits<char> >(std::__1::basic_ostream<char, std::__1::char_traits<char> >&, char const*, unsigned long) at ostream:734
```

ちょっと読みにくいですが
0x100000774:  cmpl   $0x0, 0x975(%rip)         ; (void *)0x0000000000000000
0x10000077b:  sete   %al
flag == 0ならば　alレジスタに1を設定、それ以外は0を設定します
flag == 0なので alレジスタには1が設定されました

0x10000077e:  testb  $0x1, %al
0x100000780:  movb   $0x1, %al
0x100000782:  jne    0x10000077e               ; worker() + 14 at main.cpp:27
alレジスタと 0x1を比較（AND）します。alレジスタは0x1なので　0x1となります
alレジスタに 0x1を設定します
上記の testの値が 非ゼロの場合 再び testb にジャンプします
今回は 0x1だったのでジャンプします
そして何度たっても alの値は0x1のため無限ループをします


##なぜ コンパイラ最適化で無限ループになるのか？

コードのこの部分に注目
　
```cpp:
void worker() {
    while( flag == 0){
    }
    std::cout << "worker!! \n";
}
```

局所的に見ると、このflagの値はどこからも設定されませんので
コンパイラにとっては、関数内では変化しない値と認識されます
関数に入った時はflag==0のはずなので、当然無限ループになります

なので、コンパイラに対して、flagという変数が、スレッドやI/O待ち等で変更される可能性がある事を教え
最適化を禁止させる必要があります


#最適化禁止にはvolatile

そこで今回のテーマのvolatileの登場
volatileは変数に付ける修飾子で、コンパイラによる最適化を禁止させる働きがあります
さっそく　volatileを加えたコード


```cpp:volatile
#include <iostream>
#include <thread>


volatile int flag = 0;

void worker() {
    while( flag == 0){
    }
    std::cout << "worker!! \n";
   
}

auto main(int argc, const char * argv[]) -> int {
    std::cout << "start\n";

    
    std::thread th(worker);
    
    std::this_thread::sleep_for(std::chrono::seconds(5));
    flag = 1;
    
    th.join();
    
    
    return 0;
};
```

flagの変数にvolatile属性を加えただけですが、これだけで正しく動作します

アセンブラをみてみましょう

```:volatile
0x100000780:  pushq  %rbp
0x100000781:  movq   %rsp, %rbp
0x100000784:  cmpl   $0x0, 0x965(%rip)         ; (void *)0x0000000000000000
0x10000078b:  je     0x100000784               ; worker() + 4 at main.cpp:27
0x10000078d:  movq   0x87c(%rip), %rdi         ; (void *)0x00007fff7a3302f8: std::__1::cout
0x100000794:  leaq   0x75d(%rip), %rsi         ; "worker!! \n"
0x10000079b:  movl   $0xa, %edx
0x1000007a0:  popq   %rbp
0x1000007a1:  jmp    0x10000097e               ; std::__1::basic_ostream<char, std::__1::char_traits<char> >& std::__1::__put_character_sequence<char, std::__1::char_traits<char> >(std::__1::basic_ostream<char, std::__1::char_traits<char> >&, char const*, unsigned long) at ostream:734
```

0x100000784:  cmpl   $0x0, 0x965(%rip)         ; (void *)0x0000000000000000
0x10000078b:  je     0x100000784               ; worker() + 4 at main.cpp:27
flagの値と 0x0を比較し 同じであれば再び cmpに飛ぶ

非常にシンプルかつ、正しい動きになりました

このように　volatileは 他のスレッド、I/O待により値を書き換えられる可能性がある変数に対して
コンパイラの最適化を抑制する 修飾子です


#しかし最適化を全て禁止したくない
上記の対策で　まず問題ありませんが
せっかくコンパイラが最適化をしてくれているのに
flag に関わる場所を全部最適化禁止するのは　もったいない
そう感じるのが Cゲンガーでしょう

この1カ所のみ最適化を阻止する方法は色々考えられます
例えば

1. この関数を別ファイルにし、そのファイルには最適化を行わない
1. インラインアセンブラで書く
1. キャストを使い局所的にvolatileにする
1. メンバ関数をvolatile指定する

1 については、makefileをいじってください
参考までに他の方法を


##インラインアセンブラで最適化阻止

```cpp:インラインアセンブラ

#include <iostream>
#include <thread>


int flag = 0;

void worker() {
    
    asm volatile(
                "loop:               \n\t"
                "movl (%0), %%eax    \n\t"
                "cmp $0x0, %%eax     \n\t"
                "je loop             \n\t"
                : :"r" (&flag) : "%eax"
            );
    std::cout << "worker!! \n";
}

auto main(int argc, const char * argv[]) -> int {
    std::cout << "start\n";

    
    std::thread th(worker);
    
    std::this_thread::sleep_for(std::chrono::seconds(5));
    flag = 1;
    
    th.join();
    
    return 0;
};
```

あまりアセンブラ得意ではないので適当ですが
(AT&T記法で flagのアドレス値を直接参照する方法誰か知りませんかね・・)
flagに volatile修飾していないので、flagは最適化対象です

が、最適化して欲しくないループの部分を インラインアセンブラで書きます。
asmのあとのvolatileは 念のため入れておいたほうが良いでしょう

flagのアドレスをレジスタ変数に入れ、その値をチェックしています
アセンブラなので アドレスで取って下さい！ flagの値ではダメですよ！

一応、暗黒魔術ですが これで問題なく動きます


念のためのアセンブリ

```:インラインアセンブラ
0x100000770:  pushq  %rbp
0x100000771:  movq   %rsp, %rbp
0x100000774:  leaq   0x975(%rip), %rcx
0x10000077b:  movl   (%rcx), %eax
0x10000077d:  cmpl   $0x0, %eax
0x100000780:  je     0x10000077b               ; worker() + 11 at main.cpp:30
0x100000782:  movq   0x887(%rip), %rdi         ; (void *)0x00007fff7a3302f8: std::__1::cout
0x100000789:  leaq   0x758(%rip), %rsi         ; "worker!! \n"
0x100000790:  movl   $0xa, %edx
0x100000795:  popq   %rbp
0x100000796:  jmp    0x10000096e               ; std::__1::basic_ostream<char, std::__1::char_traits<char> >& std::__1::__put_character_sequence<char, std::__1::char_traits<char> >(std::__1::basic_ostream<char, std::__1::char_traits<char> >&, char const*, unsigned long) at ostream:734
```

0x100000774:  leaq   0x975(%rip), %rcx
0x10000077b:  movl   (%rcx), %eax
0x10000077d:  cmpl   $0x0, %eax
0x100000780:  je     0x10000077b               ; worker() + 11 at 

&flagを取得し、その値が0以外になるのを待ってます。正しい動きですね！
（本来は 上３行は 1つのニーモニックに落とせるのだが AT&T記法がわからぬため、無駄な処理になってます）

##キャストを使い局所的にvolatileにする
インラインアセンブラによる最適化阻止は黒魔術ですね、ちょっと強引だし
なにより、CPUやコンパイラ依存なので移植時に問題が出ます
ので、おおよそ正しくは　このように処理をするのではないかと。

```cpp:キャスト

#include <iostream>
#include <thread>


int flag = 0;

void worker() {

    volatile int *p = &flag;
    while( *p == 0){
    }
    std::cout << "worker!! \n";
    
}

auto main(int argc, const char * argv[]) -> int {
    std::cout << "start\n";

    
    std::thread th(worker);
    
    std::this_thread::sleep_for(std::chrono::seconds(5));
    flag = 1;
    
    th.join();
    
   
    return 0;
};
```

flagはvolatile修飾してないので最適化対象です
volatile int *p = &flag;
にて、flagのアドレスを取得し volatile修飾しています
これが今回の ポイントです。
このため、 ポインタpは 最適化の対象外となり
局所的に最適化を止める事ができました。


アセンブリです

```:キャスト
0x100000780:  pushq  %rbp
0x100000781:  movq   %rsp, %rbp
0x100000784:  cmpl   $0x0, 0x965(%rip)         ; (void *)0x0000000000000000
0x10000078b:  je     0x100000784               ; worker() + 4 at main.cpp:20
0x10000078d:  movq   0x87c(%rip), %rdi         ; (void *)0x00007fff7a3302f8: std::__1::cout
0x100000794:  leaq   0x75d(%rip), %rsi         ; "worker!! \n"
0x10000079b:  movl   $0xa, %edx
0x1000007a0:  popq   %rbp
0x1000007a1:  jmp    0x10000097e               ; std::__1::basic_ostream<char, std::__1::char_traits<char> >& std::__1::__put_character_sequence<char, std::__1::char_traits<char> >(std::__1::basic_ostream<char, std::__1::char_traits<char> >&, char const*, unsigned long) at ostream:734
```

0x100000784:  cmpl   $0x0, 0x965(%rip)         ; (void *)0x0000000000000000
0x10000078b:  je     0x100000784               ; worker() + 4 at main.cpp:20
はい、完璧ですね！

ただし、ポインタを使い間接参照を行っているので
環境により、ポインタ演算が最適化されず、必ず速くなる保証はありません！


##default volatileで部分的に最適化対象にする
上記の反対で
デフォルトは最適化阻止、局所的に最適化を行いたいという場合
（volatile必要な変数は 不具合考え volatileで宣言すべきなので、上記よりこちらが良いとおもいます）

volatile int flag = 0;
と volatile修飾をします。

最適化してよい箇所は　上記の逆で

    int *p = const_cast<int*>(&flag);

と、volatileを落として使うと、最適化対象になります。


ただし、ポインタを使い間接参照を行っているので
環境により、ポインタ演算が最適化されず、必ず速くなる保証はありません！



##メンバ関数でvolatile指定
メンバ関数であればvolatileを指定し、関数自体の最適化を排除できます
オブジェクト指向で開発している場合は、volatileなgetterを作る
ベストだとおもいます


```cpp:メンバ関数
#include <iostream>
#include <thread>

class test{
public:
 void worker(){
    
    while( flag_v() == 0){
    }
    std::cout << "worker!! \n";
 }
  
    int flag_v() volatile {return(flag_);};
    int flag() {return(flag_);};
    void setFlag( int flag ) { flag_ = flag; };
    
private:
      int flag_ = 0;
     };

auto main(int argc, const char * argv[]) -> int {
    std::cout << "start\n";

    test t;
    std::thread th( &test::worker, &t );
    
    std::this_thread::sleep_for(std::chrono::seconds(5));
    t.setFlag(1);
    
    th.join();
    
    
    return 0;
};

```

このように、classにし
    int flag_v() volatile {return(flag_);};
と、getterにvolatileを指定すると、最適化が抑制され
正常に動きます
普段は最適化して欲しいので volatile有無で２つ関数作ると良いと思います

ただし、メンバ変数でしかvolatileは指定出来ないため
グローバルの関数では不可能です
一般的な用途としては クラスになっていると思うのでほとんどこれで対応出来るでしょう

ただし、現状では ラムダ関数には volatileを修飾できませんので
ラムダ関数で行う場合には、上記の volatile *にキャストする必要があるでしょう

一応 ラムダに volatileやconst修飾が出来るような提案は出ているので
そのうち ラムダでもvolatile修飾出来るようになるんじゃないかな。
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2651.pdf



#マルチスレッドでvolatileが同期すると思うな
すこしC言語に詳しい方ならよく知っていると思いますが
意外と面倒な話
メモリバリアの問題です

上記のvolatile修飾すれば、一見他のスレッドでflagが書き換えられた場合
即座に反映されるように見えますが
マルチスレッドの場合は、異なるCPUコアで動いている場合があります

CPUには一次キャッシュ、二次キャッシュ、三次キャッシュ
あるいはメモリキャッシュ等、色々なキャッシュが存在して
最適化の為に、CPUコアはそれぞれ独自にメモリをキャッシュしているかもしれません
例えば 他スレッドが別のコアで動作している場合、他スレッドが キャッシュしているflagに1を設定した場合
その書き込みがwrite backされ、自分のコアが 再びキャッシュ更新するまでは
flagの値の更新がわかりません！！

プロセッサによっては、メモリがwriteされた場合は即座にキャッシュを更新する作りになっているものもありますが
全てとは限らないので
機種依存の不具合になります

ので、他スレッドから値が更新されるのを期待する場合には
mutexや、lock free等を使い、データの同期処理を行って下さい
C++11だと std::atomic<T> を使えばベストだと思います
（異論もとむ）

あくまでvolatileで同期出来るのは、シングルスレッドでの処理
I/Oのwait　程度だと思います


#おまけ
boost.coroutine を使うと、シングルスレッドで 非同期処理を行う事が出来ます
とっても便利なので　みんな使ってね！

で、その場合　シングルスレッドだが他のコンテキスト(Fiberとか呼ばれたりする)
により値が変更される事があるが
その際は 恐らく、シングルスレッドで同じコアで動作しているので
mutexなどが不要で、volatileのみで同期が出来ると　考えているが
それが本当に正しいか・・・・　調査中です。

知っている人いたら教えて下さい。
原子性、順序性には絶対に問題はないと思いますし
可視性にたいして、coroutineのcontextで問題になる可能性も低いと思っています。。