マーク＆スイープ勉強会

マーク＆スイープ勉強会七誌

マーク＆スイープ• GCのアルゴリズムの一種• GC中はプログラムが停止する – これはstop the worldと呼ばれる• 停止時間を短くするために色々な工夫がある – 世代別GC、Concurrent GCなど• これらはマーク＆スイープの発展系• 今回は基礎となる単純なマーク＆スイープに的を絞る

今回の流れ• 単純なマーク＆スイープGCを実装する• 対象はシングルスレッドに限定 – マルチスレッドは単純なマーク＆スイープでは対応できないため、前のスライドで取り上げたような発展系のアルゴリズムが必要• 大まかに説明した後、実装のための自由時間とします – 自由時間を長めに取りたいので、説明はざっくり – 自由時間に質問を受け付けます。お気軽に！

第1部メモリを覗いてみよう

ローカル変数 (1)• まず次のようなケースで、使用しなくなったポインタをどう検出するか考える#include <stdlib.h> 2. 宙に浮くint main() { void *a = malloc(10); void *b = malloc(10); a = NULL;} 1. ポインタを上書き

ローカル変数 (2)• メモリ管理やポインタについて調べる前に、ローカル変数がメモリにどう格納されているのかを確認する#include <stdio.h>int main() { int a = 0x12345678, b = 0xcafebabe; printf("&a: %p¥n", &a); printf("&b: %p¥n", &b);} &a: 0028FF1C 実行結果 &b: 0028FF18

ローカル変数 (3)• デバッガで見てみる入力

スタックフレーム (1)• ローカル変数周りのメモリは、大まかに以下のような構造になっている小（ワークエリア）ローカル変数アドレス（ワークエリア）大引数• この構造をスタックフレームと呼ぶ

スタックフレーム (2)• ローカル変数より引数のアドレスが大きいことを確認してみる#include <stdio.h>int main(int argc, char *argv[]) { int a; printf("&a : %p¥n", &a); printf("&argc: %p¥n", &argc); printf("&argv: %p¥n", &argv);} &a : 0028FF1C 実行結果 &argc: 0028FF30 &argv: 0028FF34

スタックフレーム (3)• 関数を呼び出すと、スタックフレームはどんどん上（アドレスの小さい方）に積み重なるa() から b() を呼ぶ小 b() の void b() { } スタックフレームアドレス void a() { 大 a() の b(); } スタックフレーム

スタックフレーム (4)• 関数を呼び出すとスタックフレームが上に積み重なることを確認してみる#include <stdio.h>int b(int a) { printf("&a : %p¥n", &a);}int main(int argc, char *argv[]) { printf("&argc: %p¥n", &argc); b(0);} 実行結果 &argc: 0028FF30 &a : 0028FF10

変数探し• スタックフレームを走査して変数を検出#include <stdio.h>void search(int *start, int value) { for (int *p = start; p > &value; p--) { if (*p == value) { printf("found: %p¥n", p); return; } }}int main(int argc, char *argv[]) { 実行結果 int a = 0xcafebabe; printf("&a: %p¥n", &a); &a: 0028FF1C search(&argc, a); found: 0028FF1C}

malloc (1)• 冒頭の問題に戻る#include <stdlib.h>int main() { void *a = malloc(10); void *b = malloc(10); a = NULL;}• malloc() の戻り値を記録しておいて、スタックフレームに含まれるか確認すれば良い

malloc (2)• malloc() の戻り値を記録する例#include <stdlib.h>#include <map>static std::map<void *, bool> mallocs;void *gc_malloc(size_t size) { void *ret = malloc(size); mallocs[ret] = true; return ret;}

問題 1• 以下のコードで使われている gc_init(), gc_malloc(), gc_collect() を実装してください。• ※ 最初に掲示した問題を改変しました。 #include <stdlib.h> int main(int argc, char *argv[]) { gc_init(&argc); void *a = gc_malloc(10); void *b = gc_malloc(10); a = NULL; gc_collect(); }

問題 1 の回答例static void **stack_start;void gc_init(int *pargc) { stack_start = reinterpret_cast<void **>(pargc);}void gc_collect() { void *end; for (auto it = mallocs.begin(); it != mallocs.end(); ++it) it->second = false; for (auto p = stack_start; p > &end; p--) if (mallocs.find(*p) != mallocs.end()) mallocs[*p] = true; for (auto it = mallocs.begin(); it != mallocs.end();) if (it->second) ++it; else { free(it->first); mallocs.erase(it++); }}

マーク＆スイープ問題 1 の回答例について説明1. mallocsの値をすべてfalseにする2. スタックフレームを走査して、見付けたものをtrueにする3. falseのままになっている領域を解放する2のフェーズをマーク、3をスイープと呼ぶ

保守的なGC• 偶然 mallocsに含まれるのと同じ値がメモリに含まれている可能性がある。• その場合、解放されないまま残る。• GCが誤って解放し過ぎるとアクセスしたときに落ちるが、解放されずに残っても多少リークする程度で実害はない。• そのように割り切ったGCを『保守的なGC』と呼ぶ。

第2部ポインタを追ってみよう

問題 2• 生きている領域が解放されないようにGCを修正してください。#include <stdlib.h>struct Test { void *ptr; };int main(int argc, char *argv[]) { gc_init(&argc); Test *t = reinterpret_cast<Test *>( gc_malloc(sizeof(Test))); t->ptr = gc_malloc(10); gc_collect();} 生きているのに回収されてしまう！

問題 2 の回答例（抜粋）struct HeapInfo { size_t size, sizep; bool marked; };static std::map<void *, HeapInfo> mallocs;void *gc_malloc(size_t size) { void *ret = malloc(size); HeapInfo hi = { size, size / sizeof(void *), true }; mallocs[ret] = hi; return ret;}static void gc_scan(void **start, void **end) { for (auto p = start; p < end; p++) { auto it = mallocs.find(*p); if (it != mallocs.end() && !it->second.marked) { it->second.marked = true; auto pp = reinterpret_cast<void **>(*p); gc_scan(pp, pp + it->second.sizep); } }}

問題 3• 無駄なスキャンを抑制してください。struct Test { void *ptr; int *buf; };int main(int argc, char *argv[]) { gc_init(&argc); Test *t = reinterpret_cast<Test *>( gc_malloc(sizeof(Test))); t->ptr = gc_malloc(10); t->buf = reinterpret_cast<int *>( gc_malloc(1024 * 1024)); gc_collect();} ポインタが含まれていない内部の走査は無駄！

問題 3 の回答例（抜粋） • 内部を走査するか指定できるようにするstruct HeapInfo { size_t size, sizep; bool marked, scan; };void *gc_malloc(size_t size, bool scan = true) { 略 }static void gc_scan(void **start, void **end) { 略 it->second.marked = true; if (it->second.scan) { 略 } 略}int main(int argc, char *argv[]) { 略 t->buf = reinterpret_cast<int *>( gc_malloc(1024 * 1024, false)); gc_collect();}

第3部C++で使いやすく

new (1)• 以前出てきた例を改めて見返すと・・・#include <stdlib.h>struct Test { void *ptr; };int main(int argc, char *argv[]) { gc_init(&argc); Test *t = reinterpret_cast<Test *>( gc_malloc(sizeof(Test))); t->ptr = gc_malloc(10); gc_collect();} いくら何でも冗長過ぎる！ newで簡単に書けないか？

new (2)• operator newを置き換えると無条件にGC対象となってしまうため、意図的にGCを外したいときに不便• newした後、GCに登録する関数を用意Test *t = gc_register(new Test);• 常にGC対象にしたいクラスはコンストラクタで自分を登録すれば良いstruct Test { Test() { gc_register(this); }};

new (3)• deleteで解放するため、解放処理をコールバックとして登録できるようにする• free() と同じ型の関数ポインタで登録するため、delete のラッパーを用意template <class T> void gc_delete(void *p) { delete reinterpret_cast<T *>(p);}template <class T> void gc_delete_array(void *p) { delete [] reinterpret_cast<T *>(p);}

実装例（抜粋）struct HeapInfo { size_t size, sizep; bool marked, scan; void (*free)(void *);};void gc_register(void *p, size_t size, bool scan, void (*free)(void *)) { HeapInfo hi = { size, size / sizeof(void *), true, scan, free }; mallocs[p] = hi;}void *gc_malloc(size_t size, bool scan = true) { void *ret = malloc(size); gc_register(ret, size, scan, free); return ret;}template <class T> T *gc_register(T *t) { gc_register(t, sizeof(T), true, gc_delete<T>); return t;}

GCポインタ (1)• グローバル変数や非GC対象インスタンスのメンバは走査対象とならないint *p = gc_new<int>(); 生きているのにstruct Test { int *ptr; }; 回収されてしまう！int main(int argc, char *argv[]) { gc_init(&argc); Test *t = new Test; t->ptr = gc_new<int>(); gc_collect();}

GCポインタ (2)• スマートポインタと同じような発想でGCポインタを作ってマーク対象とするgc_ptr<int> p = gc_new<int>();struct Test { gc_ptr<int> ptr; };int main(int argc, char *argv[]) { gc_init(&argc); Test *t = new Test; t->ptr = gc_new<int>(); gc_collect();}

実装例（抜粋）static std::list<void **> gc_ptrs;template <class T> class gc_ptr { T *ptr; std::list<void **>::iterator it; void init(T *p) { ptr = p; gc_ptrs.push_back(reinterpret_cast<void **>(&ptr)); it = --gc_ptrs.end(); }public: gc_ptr() { init(NULL); } gc_ptr(const gc_ptr<T> &p) { init(p.ptr); } gc_ptr(T *p) { init(p); } ~gc_ptr() { gc_ptrs.erase(it); } gc_ptr<T> &operator =(T *p) { ptr = p; return *this; } inline operator T *() const { return ptr; }};

クロージャ (1)• C++のラムダ式はキャプチャによって環境を閉じ込めているわけではないため、厳密にはクロージャではないと言われる• 以下の例ではローカル変数をキャプチャしているが、単なる参照のため、スコープアウト後に使用してはいけないstd::function<int()> test() { int a = 0; return [&] { return ++a; };}

クロージャ (2)• GCがあれば、キャプチャ対象を気軽にヒープに確保することができるstd::function<int()> test() { gc_ptr<int> a = gc_new<int>(); *a = 0; return [=] { return ++(*a); };}int main() { auto f = test(); printf("%d¥n", f()); gc_collect(); printf("%d¥n", f()); f = [] { return 0; }; gc_collect(); ここでキャプチャされた printf("%d¥n", f()); aが指す先が解放される}

クロージャ (3)• ヒープを使う方式は、ローカル変数のキャプチャに参照を使う F# と同じ構造• ヒープへのポインタを値束縛することで、環境を閉じ込めたように見せかけている std::function<int()> test() { gc_ptr<int> a = gc_new<int>();C++ with GC *a = 0; return [=] { return ++(*a); }; } let test () =F# let a = ref 0 fun () -> a := !a + 1; !a

第4部自動調節

閾値 (1) • 今までは手動で gc_collect を呼んでいた • GCに登録するときに使用メモリ量をカウントして、閾値を超えたら呼ぶことで自動化static size_t mem_used;static size_t threshold = 1024 * 1024;void gc_register(void *p, size_t size, bool scan, void (*free)(void *)) { HeapInfo hi = { size, size / sizeof(void *), true, scan, free }; mallocs[p] = hi; mem_used += size; if (mem_used > threshold) gc_collect();}

閾値 (2) • スイープの際に使用メモリ量を減らす • 最終的に確定した使用量で閾値を調整void gc_collect(void *dummy) { 略 for (auto it = mallocs.begin(); it != mallocs.end();) { if (it->second.marked) ++it; else { printf("sweep: %p¥n", it->first); (*it->second.free)(it->first); mem_used -= it->second.size; mallocs.erase(it++); } } while (mem_used > (threshold >> 1)) threshold <<= 1;}

閾値 (3)• 自動的に gc_collect() が呼ばれるようになるint main(int argc, char *argv[]) { gc_init(&argc); for (int i = 0; i < 10; i++) gc_malloc(300 * 1024, false);}• 処理内容によってGCの特性は異なる – 巨大なサイズが少数確保される場合 – 小さいサイズが大量に確保される場合• サイズや個数も考慮すると効率が上がる

ご清聴ありがとうございました

マーク＆スイープ勉強会

by n 7shi on Dec 13, 2011

Accessibility

Categories

Tags

Upload Details

Usage Rights

2 Embeds 1,080

Statistics

マーク＆スイープ勉強会 — Presentation Transcript

http://d.hatena.ne.jp	1079
http://hatenatunnel.appspot.com	1