そろそろvolatileについて一言いっておくか
わんくま同盟 東京勉強会 #35
自己紹介
•
•
•
•
H/N: yamasa
FreeBSD使い
Java屋
モバイル大好き
わんくま同盟 東京勉強会 #35
今日のキーワード
•
•
•
•
•
アトミック変数
メモリバリア
happens before
正しく同期化されたコード
volatile
わんくま同盟 東京勉強会 #35
マルチスレッドと排他制御
マルチスレッドプログラミングで苦労する点
– 同じ変数やオブジェクトが複数のスレッドから
同時にアクセスされる可能性がある。
mutex などの排他制御(ロック)を使って対処
– あらゆる変数を排他制御しなければならないの?
ロックによるパフォーマンスの劣化も気になる。
⇒ もっと軽量の仕組みはないの?
わんくま同盟 東京勉強会 #35
スレッド間通信のprimitive
• スレッド間でデータをやり取りするための最も
基本的な仕組み(primitive)
それが… volatile
アトミック変数とメモリバリア
わんくま同盟 東京勉強会 #35
アトミック変数とは
「アトミック変数」とは
• 複数スレッドが同時に読み書きなどの操作を
行っても、それらの操作が順々に行われてい
るように見えることが保証されている変数
わんくま同盟 東京勉強会 #35
アトミック変数へのloadとstore (1)
// 初期値
atomic<int> a = -1
スレッド1:
// aに1を代入(store)
a.store(1)
スレッド2:
// aの値を読み出す(load)
r = a.load()
r の値は -1 または 1 のどちらかになることが保証される
わんくま同盟 東京勉強会 #35
アトミック変数へのloadとstore (2)
// 初期値
atomic<int> a = 0
スレッド1:
a.store(1)
スレッド2:
a.store(-1)
a の値は
0 ⇒ 1 ⇒ -1
0 ⇒ -1 ⇒ 1
のいずれかの順序で変化することが保証される
わんくま同盟 東京勉強会 #35
load, storeのアトミック性
• 当たり前のようだが非常に大切な性質
– アトミック性が保証されない変数に対して同様に
アクセスした場合、たとえば上位bitと下位bitが混
ざった値になってしまうかも…
(例: 32bitアーキテクチャでの int64_t (long long)
型変数への読み書き)
わんくま同盟 東京勉強会 #35
アトミック変数への複雑な操作
• 多くのアトミック変数の実装には、読み込みと
書き込みを同時に行う操作も提供されている
r1 = a.exchange(r2)
⇒ { r1 = a; a = r2; } // 読み込みと同時に書き込み
r1 = a.fetch_add(r2)
⇒ { r1 = a; a = a + r2; } // 読み込みと同時に加算
など…
わんくま同盟 東京勉強会 #35
アトミック変数のもう一つの性質
• アトミック変数への書き込みは、いずれ必ず
他スレッドからも見えるようになる。
atomic<int> a = 0;
スレッド1:
a.store(1);
スレッド2:
while (a.load() != 1) {
}
この場合、スレッド2のwhile文は無限ループに
ならないことが保証される。
わんくま同盟 東京勉強会 #35
アトミック変数と普通の変数の違い
• アトミック変数は、複数のスレッドからアクセ
スされても大丈夫なように設計された変数
⇒ アトミックではない普通の変数は、マルチスレッ
ドでは予期せぬ実行結果になることがある。
マルチスレッドプログラムでは全ての変数をアトミッ
ク変数にしなければならないの?
⇒ No!
• 普通の変数についても、マルチスレッドでの
動作を保証する仕組みが別に存在する!
わんくま同盟 東京勉強会 #35
• 以後の説明では変数を以下のように
表記します
a, a1, a2 …
アトミック変数
x, y, z
スレッド間でアクセスされる可能性がある
アトミック変数以外の普通の変数
r, r1, r2 …
ローカル変数(レジスタ)
また、明示的に示さない場合の各変数の初期値は0とします
わんくま同盟 東京勉強会 #35
リオーダーとは?
「リオーダー」
• プログラム実行速度の向上などの目的で実
行順序を入れ替える、最適化手法の一つ
– コンパイラがプログラムコードを機械語に変換す
るとき
– CPUが機械語のコードを実際に実行するとき
キャッシュメモリの影響などを考慮して命令の実行
順序を入れ替える
わんくま同盟 東京勉強会 #35
リオーダーが出来ない状況
• 当然ながら、実行結果が変わってしまうような
リオーダーは禁止
x = 1;
y = x;
// …①
// …②
⇒ ①と②を入れ替えると y に代入される値が
変わってしまうのでダメ!
⇒でも、②の右辺を定数1に置換する最適化はOK
わんくま同盟 東京勉強会 #35
リオーダーできる例
• では、以下の例はリオーダー可能?
// 例1
x = 1;
y = 1;
// …①
// …②´
// 例2
r1 = y;
r2 = x;
// …③
// …④
最終的な実行結果は変わらないので、
①と②´、③と④をそれぞれ入れ替えるのはOK
わんくま同盟 東京勉強会 #35
…ただし、シングルスレッドに限る
• 前述の例をマルチスレッド化すると…
// スレッド1
x = 1;
// …①
y = 1;
// …②´
// スレッド2
r1 = y;
r2 = x;
// …③
// …④
• r1 == 1 && r2 ==0 となることはありえない、
…はず。
• でも、リオーダーを考慮すると、ありえる。
わんくま同盟 東京勉強会 #35
マルチスレッドでの最適化の困難さ
• マルチスレッドでは、ちょっとした最適化でも
実行結果に影響を及ぼす。
⇒ マルチスレッドでの実行結果にも影響しない
ようにリオーダーなどを制限すると、最適化す
る余地がほとんど無くなってしまう!!
わんくま同盟 東京勉強会 #35
マルチスレッドでの最適化の原則
よって、最適化の規則を以下のように定める。
• シングルスレッドでの実行結果が変わらない
限り、どんな最適化も基本的には許可する。
• 最適化がマルチスレッドでの動作に悪影響を
及ぼさないよう、最適化を制限する手段を処
理系は提供する。
⇒ それが「メモリバリア(メモリフェンス)」
わんくま同盟 東京勉強会 #35
メモリバリアの基本は2種類
releaseバリア
命令①
release_barrier();
命令②
• releaseバリア
OK
OK
acquireバリア
命令①
acquire_barrier();
命令②
先行する命令が、バリアを超えて後ろにリオーダー
されるのを禁止する。
• acquireバリア
後続の命令が、バリアを超えて前にリオーダーされ
るのを禁止する。
わんくま同盟 東京勉強会 #35
アトミック変数とメモリバリアの組み合わせ
• アトミック変数とメモリバリアは一緒に用いる
アトミック変数へのstore + releaseバリア
処理①
a.store_release(r);
アトミック変数からのload + acquireバリア
r = a.load_acquire();
処理②
わんくま同盟 東京勉強会 #35
• アトミック変数とメモリバリアを組み合わ
せることで、異なるスレッドの命令間に
順序付けをすることができる。
atomic<int> a = 0;
スレッド1:
x = 1;
// …①
a.store_release(1);
int x = 0;
スレッド2:
r1 = a.load_acquire();
if (r1 == 1) {
r2 = x; // …②
}
わんくま同盟 東京勉強会 #35
スレッド1:
x = 1; // …①
a.store_release(1);
スレッド2:
synchronize with
r1 = a.load_acquire();
if (r1 == 1) {
r2 = x; // …②
}
• store_release()で書き込んだ値を
load_acquire()で読み込むことで、
2つの間に前後関係が生まれる。
• この関係を “synchronize with” と呼ぶ。
わんくま同盟 東京勉強会 #35
スレッド1:
x = 1; // …①
a.store_release(1);
スレッド2:
s.w.
r1 = a.load_acquire();
if (r1 == 1) {
r2 = x; // …②
}
• releaseバリアのため、①の書き込みは必ず
store_release() より前に行われる。
• acquireバリアのため、②の読み込みは必ず
load_acquire() の後に行われる。
(要するに、xの値の先読みは禁止!)
わんくま同盟 東京勉強会 #35
スレッド1:
x = 1; // …①
a.store_release(1);
happens before
スレッド2:
r1 = a.load_acquire();
if (r1 == 1) {
r2 = x; // …②
}
• synchronize with関係とメモリバリアの効果
により、①と②の間に保証された順序関係が
生じる。
• この関係(“happens before” と呼ぶ)が存
在することにより r2 == 1 が保証される。
わんくま同盟 東京勉強会 #35
推移的なhappens before関係(1)
スレッド1:
スレッド2:
スレッド3:
h.b.
x = 1; // …①
a1.store_release(1);
r1 = a1.load_acquire();
if (r1 == 1) {
h.b.
r = x; // …②
a2.store_release(1); r2 = a2.load_acquire();
}
if (r2 == 1) {
x = 2; // …③
}
• ①の書き込みは②より前だが、③の書き込み
は②より後。
⇒ よって r == 1 となる。
わんくま同盟 東京勉強会 #35
推移的なhappens before関係(2)
スレッド1:
スレッド2:
スレッド3:
h.b.
x = 1; // …①
a1.store_release(1);
r1 = a1.load_acquire();
if (r1 == 1) {
h.b.
x = 2; // …②
a2.store_release(1); r3 = a2.load_acquire();
}
if (r3 == 1) {
r = x; // …③
}
• ①で書き込まれた値は、その後の②で書き込
まれた値によって上書きされる。
⇒ よって r == 2 となる。
わんくま同盟 東京勉強会 #35
happens before関係がない場合(1)
スレッド1:
スレッド2:
h.b.
h.b.
x = 1; // …①
a.store_release(1);
r1 = a.load_acquire();
if (r1 == 1) {
?
r2 = x; // …②
}
スレッド3:
r3 = a.load_acquire();
if (r3 == 1) {
r4 = x; // …③
}
• ②も③も、①より後なので、 r2 == 1 かつ
r4 == 1 となる。
• ②と③の間には happens before の関係が
無いが、問題ない。
わんくま同盟 東京勉強会 #35
happens before関係がない場合(2)
スレッド1:
x = 1; // …①
a1.store_release(1);
スレッド2:
?
r1 = a1.load_acquire();
r2 = a2.load_acquire();
if (r1 == 1 && r2 == 1) {
r = x; // …③
}
スレッド3:
x = 2 // …②
a2.store_release(1);
• ①と②の間には happens before の関係が
ない。
⇒このような状態を “data race” と呼ぶ。
わんくま同盟 東京勉強会 #35
happens before関係がない場合(3)
スレッド1:
x = 1;
// …①
a.store_release(1);
x = 2;
// …③
?
h.b.
スレッド2:
r1 = a.load_acquire();
if (r1 == 1) {
r = x;
// …②
}
• ②と③の間には happens before の関
係がない。
⇒これも “data race” である。
わんくま同盟 東京勉強会 #35
data raceとは
• アトミック変数ではない普通の変数に対して、
異なるスレッド上からの
– 書き込みと書き込み
– 書き込みと読み込み
または
があり、2つの間に happens before の関係
がない場合を “data race” と呼ぶ。
わんくま同盟 東京勉強会 #35
data race が起きると?
• data race の結果はどうなるのか?
– Javaの場合
「あらゆる最適化を考慮した上で起こり得る、全
ての結果候補のうちのいずれか」
– C++の場合
undefined (未定義)。「何が起こるかわからない」
• 要するに、「data raceが起きた時点で負け」
– data race が起きないプログラムコードのことを、
「正しく同期化されている」と呼ぶ
わんくま同盟 東京勉強会 #35
正しく同期化されたコードを書くには
• 正しく同期化されたコードを書くための三か条
– 変更したデータを、他スレッドからもアクセスでき
るようにするときは、releaseバリアを発行する。
– 他スレッドが変更したデータへアクセスするときに
は、acquireバリアを発行する。
– あるデータを他スレッドが読み書きしているタイミ
ングでは、そのデータへの書き込みを行わないよ
うにする。
わんくま同盟 東京勉強会 #35
正しく同期化されたコードの例(1)
Hoge* x;
atomic<bool> a = false;
スレッド1:
スレッド2:
x = new Hoge();
a.store_release(true); while (!a.load_acquire()) {
}
h.b.
x->foo();
• 正しく同期化されているので、Hogeオブジェ
クトへはスレッド2から安全にアクセスできる。
わんくま同盟 東京勉強会 #35
正しく同期化されたコードの例(2)
atomic<Hoge*> a = NULL;
スレッド1:
スレッド2:
Hoge* r1 = new Hoge(); Hoge* r2;
a.store_release(r1);
do {
r2 = a.load_acquire();
} while (r2 == NULL);
h.b.
r2->foo();
• 正しく同期化されているので、Hogeオブジェ
クトへはスレッド2から安全にアクセスできる。
わんくま同盟 東京勉強会 #35
スピンロックへの応用
アトミック変数とメモリバリアを用いると、
いわゆる「スピンロック」も実現できる。
atomic<bool> a = false;
exchangeは、書き込むと同時に
その直前の値を返す操作
void spin_lock() {
while(a.exchange_acquire(true)) { }
}
void spin_unlock() {
a.store_release(false);
}
それぞれ acquire, release の
メモリバリアを持っていることに
注目
わんくま同盟 東京勉強会 #35
スピンロックによる同期化
スレッド1:
spin_lock();
x = 1;
spin_unlock();
スレッド2:
synchronize with
happens before
spin_lock();
r = x;
spin_unlock();
• スピンロックのもつメモリバリア効果により
happens before関係が生まれるので、変数
を安全に共有できる。
わんくま同盟 東京勉強会 #35
排他制御とメモリバリア
• スピンロックに限らず、スレッド間の排他制御
や同期化を行う仕組み(mutexやセマフォ等)
は、メモリバリア効果も持っている。
⇒ これらの仕組みを正しく使うことでも、安全な
データ共有を行うことが可能。
– “acquireバリア”, “releaseバリア” という名称も、
ロック取得と開放のもつメモリバリア効果に対応
して名付けられている。
わんくま同盟 東京勉強会 #35
ここまでのまとめ
• 最適化の影響を考えずにマルチスレッドなプ
ログラムを書くと、予期しない実行結果になる
ことがある。
• アトミック変数とメモリバリアを使って正しく同
期化されたコードを書けば、マルチスレッドで
も安全にデータ共有を行うことができる。
• ロックなどの同期化機構も、アトミック変数とメ
モリバリアで構築されている。
わんくま同盟 東京勉強会 #35
volatileの出番は?
• ここまでアトミック変数とメモリバリアについて
説明してきました。
「ところで、 volatile変数ってアトミック変数や
メモリバリアの代わりにならないの?」
⇒ 答: C/C++においては「ならない」
わんくま同盟 東京勉強会 #35
volatileの問題点その1
• volatile変数はアトミック性が保証されない
⇒ ++ や += などの演算子はもちろん、単なるload
やstoreも型によってはアトミックとならない。
volatile long long v;
v = 5;
x86用gccでコンパイル
movl $5, v
movl $0, v+4
64bit変数への代入が2命令に分かれてしまう。
わんくま同盟 東京勉強会 #35
volatileの問題点その2
• volatile変数はメモリバリア効果を持たない
volatile int v;
x = 1;
v = 2;
y = 3;
int x, y;
r1 = x;
r2 = v;
r3 = y;
volatile変数をまたいだリオーダーが自由に起こる
わんくま同盟 東京勉強会 #35
volatileの問題点その2
一応、volatile変数同士では、コンパイラによる
リオーダーはされないが…
volatile int v1, v2;
v1 = 1;
v2 = 2;
r1 = v1;
r2 = v2;
これでは、スレッド間で共有される全ての変数に
volatileを付けなければならなくなる!
わんくま同盟 東京勉強会 #35
volatileの問題点その3
• しかも、CPUによってもリオーダーされること
があるアーキテクチャでは、機械語レベルで
も「メモリバリア命令」が必要となる。
⇒ が、コンパイラがvolatile変数の読み書きに対し
てメモリバリア命令を発行してくれる保証も無い。
わんくま同盟 東京勉強会 #35
volatileに関する都市伝説
• 要するに、C/C++のvolatileはマルチスレッド
のことを何も考えていない!
「volatileと宣言された変数はマルチスレッドで
安全に使用できます。」
「複数のスレッドから読み書きされる変数には
volatileを付けて最適化を抑制しましょう。」
⇒ NG!!
わんくま同盟 東京勉強会 #35
そしてatomicへ…
• 次期C++標準である C++0x (aka C++201x)
では、アトミック変数やメモリバリアの仕様が
登場する。
• volatileに関する定義はそのままで、アトミック
型を別途定義している。
namespace std {
template<class T> struct atomic;
}
わんくま同盟 東京勉強会 #35
C++0xでのメモリバリア
• C++0xのatomic型では、メモリバリアの有無
を引数で指定する。
void store(T, memory_order = memory_order_seq_cst);
T load(memory_order = memory_order_seq_cst);
• デフォルト値は「メモリバリアあり」。
– 「ゼロオーバーヘッド原則」のC++がコストのかか
るメモリバリア付きをデフォルトとすることからも、
アトミック変数とメモリバリアを一緒に扱うことの
重要性がわかる。
わんくま同盟 東京勉強会 #35
Javaのvolatile
• 一方、Javaのvolatile変数は、load, storeの
アトミック性やメモリバリア効果を備えている。
– つまり、C++0xのatomic型に近い使い方ができ
る。
– ただし、 ++ や += 演算子はアトミックではないの
で、これらのアトミック演算が必要であれば
java.util.concurrent.atomic.Atomic* を使う。
• C/C++とJavaでは、volatileの意味が全く変
わってしまっている。
わんくま同盟 東京勉強会 #35
まとめ
• スレッド間通信のprimitiveであるアトミック変
数とメモリバリアについて。
• happens before関係の説明と、正しく同期化
されたコードの作り方。
• C/C++のvolatileは、マルチスレッドでは役立
たず。
• C++0xとJavaにおけるアトミック変数、メモリ
バリア。
わんくま同盟 東京勉強会 #35
ところで…
• 他の言語では、アトミック変数やメモリバリア
に相当する機能はどう扱われているの?
⇒ 皆さんへの宿題としますので、わかったらLT
などで発表してみてください。(笑)
わんくま同盟 東京勉強会 #35
ダウンロード

そろそろvolatileについて一言いっておくか