Boehm GC を使う

2005.2.27新規作成。（2001.7.14, 2001.7.15 の日記に加筆。）

(2020.1) 追記。

C/C++には、言語仕様としてのガベージコレクションの機能はない。動的に確保したメモリは、自分で、ただ一度だけ解放するようにプログラムを組まなければならない。解放を忘れるとメモリリークが発生し、解放しすぎるとプログラムがクラッシュすることもある。

ガベージコレクタを使うと、メモリを好きなだけ確保するだけでよく、解放は自動的にしてくれる。巨大なメモリを明示的に解放するような場合のほかは、メモリを解放するコードを書く必要はない。

The Boehm-Demers-Weiser conservative garbage collector (Boehm GC) は、C言語用のメジャーなガベージコレクタ。さまざまなソフトウェアがこのライブラリを使っている。しかし、Fedora Core 3には含まれない。

Boehm GCは、保守的GCという方法でガベージコレクトする。定期的にメモリ内を走査し、使われていないと見られるオブジェクトのメモリを回収していく。Boehm GC以外では、boost::shared_ptrが参照カウント方式を用いている。

このページでは、インストール方法のほか、簡単な使い方についても書いてみる。

インストール

入手先；A garbage collector for C and C++

2005年2月現在の最新版は、バージョン6.4。

アーカイブを展開したら、configureして、makeするだけ。configureには、次の引数を与えてみた。これでC++用ライブラリがインストールされる。 

$ ./configure --enable-cplusplus
$ make
$ su
# make install

C言語で使う

既存のプログラムでガベージコレクタを使うようにするには、メモリの確保（や必要があれば解放）の部分を修正しなければならない。

まずは単純なサンプルから。次のファイルは、とにかくメモリをどんどん確保していく。GCを使う場合は、ヘッダー<gc.h>をincludeした上で、メモリの確保をGC_MALLOC()で行う。

C++
[RAW]
  1. #include <unistd.h>
  2. #include <gc.h> // GC_MALLOC()
  3. //#include <stdlib.h> // malloc()
  5. #define ARRAY_SIZE 10000
  7. // malloc() の場合は, OOM Killer に kill される.
  8. void c_test() {
  9. char* ary[ARRAY_SIZE];
  10. while (1) {
  11. int i;
  12. for (i = 0; i < ARRAY_SIZE; i++)
  13. ary[i] = (char*) /*malloc(100000);*/ GC_MALLOC(100000);
  14. usleep(1);
  15. (void)ary[0];
  16. }
  17. }
  19. int main() {
  20. c_test();
  21. return 0;
  22. }

コンパイル・リンクは、次のようにする。-lオプションで、libgc.soをリンクする。 

$ gcc -Wall -I/usr/local/include first.c -lgc

実行中にtopコマンドなどで見ると、使用メモリが増えていかないことが分かる。GCを使わずにmalloc()でメモリを確保するようにすると、当たり前だが、どんどん使用メモリが増えていく。

C++で使う

ガベージコレクトさせるには、メモリの確保をBoehm GCにさせる必要がある。やり方は二種類ある。一つは、オブジェクトをnew演算子で生成するときにplacementを使う。new (GC) 型名 と書く。もう一つは、クラスをclass gcから派生させる。このときは、そのクラスのオブジェクトを生成するときにplacementを書かなくてもいい。

次のサンプルは大きなメモリを確保するオブジェクトを大量に生成する。

C++
[RAW]
  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <gc_cpp.h> // C++ version
  5. class Hoge: public gc {
  6. char* ptr;
  7. public:
  8. Hoge() { alloc(); }
  10. void alloc() {
  11. // gc派生型ではないので, placement を使う
  12. ptr = new (GC) char[100000];
  13. }
  15. virtual ~Hoge() {
  16. printf("destructor called.\n"); // あえて解放しない
  17. }
  18. };
  20. int main() {
  21. Hoge* p[10000];
  22. while (true) {
  23. for (int i = 0; i < 10000; i++) {
  24. p[i] = new Hoge; // gc派生型なので、単に new でよい.
  25. p[i]->alloc(); // 二重確保
  26. usleep(1);
  27. (void) p[i];
  28. }
  29. }
  30. return 0;
  31. }

上の例では, ガベージコレクタによってオブジェクトが回収されるときに, デストラクタが自動的に呼び出されない。もちろん delete演算子を使えばデストラクタが呼び出されるが、解放をガベージコレクタに任せたいというモチベイションと相容れない。

メモリ以外のリソース解放については、デストラクタに頼らずに、明示的に行うようにしなければならない。

回収されるときにデストラクタが呼び出されるようにするには

(2020.1) ソースコードを更新。

ファイルなどメモリ以外の資源を解放しなければならない場合, タイミングが不定でもいいからデストラクタを自動的に呼び出してほしい。

クラスをgc_cleanupクラスから派生すればよい. そのクラスのオブジェクトがガベージコレクトされるときに自動的にデストラクタが呼び出される。また、定期的にガベージコレクトさせるには、イベントループなどでアイドル状態のときに GC_gcollect() を呼び出すようにするといいだろう。

配列については、一層難しい。

new演算子の書き方によって、どのnewメソッドが呼び出されるかは、次のように決まっている。生成する要素数はnewメソッドには渡らないことに注意。第一引数は, (vtableを含めた) 確保すべきメモリの大きさになっている。

new演算子の書き方呼び出されるnewメソッド
new T void* operator new(sizeof(T))
new (2, f) T void* operator new(sizeof(T), 2, f)
new T[5] void* operator new[](sizeof(T) * 5 + magic)
new (2, f) T[5] void* operator new[](sizeof(T) * 5 + magic, 2, f)

これを踏まえて、次のサンプル;

C++
[RAW]
  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <gc/gc_cpp.h>
  4. #include <gc/javaxfc.h>
  6. static int global_cnt = 0;
  8. // Linux, x64
  9. constexpr int MAGIC_PADDING = 8;
  11. // gc_cleanup から派生させると, ガベージコレクトされるときにデストラクタか呼び
  12. // 出される。
  13. class Hoge: public gc_cleanup
  14. {
  15. char* ptr;
  16. int cnt;
  17. public:
  18. Hoge(): cnt(++global_cnt) {
  19. printf("hoge ctor: %d\n", cnt);
  20. ptr = new (GC) char[100000];
  21. }
  23. virtual ~Hoge() { printf(" dtor: %d\n", cnt); }
  24. };
  26. // @param memory 解放するメモリブロック。ABI (OS + CPU) に基づき, 先頭にpadding
  27. // がある.
  28. static void GC_CALLBACK MyHogeCleanUp(void* memory, void* array_size )
  29. {
  30. printf("MyHogeCleanUp() called: %p, %ld.\n", memory, (intptr_t) array_size );
  31. if (array_size) {
  32. // 注意! この方法はポータブルではない.
  33. Hoge* ptr = (Hoge*) ((char*) memory + MAGIC_PADDING);
  34. for (int i = 0; i < (intptr_t) array_size; i++)
  35. ptr[i].~Hoge();
  36. }
  37. }
  39. void cpp_test() {
  40. Hoge* foo = new Hoge();
  41. (void) foo;
  42. /*
  43. Hoge* ary;
  44. // この書き方では, デストラクタは, 100回ではなく, 先頭に対して1回しか呼び出さ
  45. // れない.
  46. ary = new Hoge[100];
  47. */
  48. // 次のようにすれば, 配列のガベージコレクト時に, コールバック関数を呼び出させ
  49. // ることができる。
  50. Hoge* ary = ::new (UseGC, MyHogeCleanUp, (void*) 100) Hoge[100];
  51. (void) ary;
  52. }
  54. int main() {
  55. // Should call GC_INIT().
  56. GC_INIT();
  58. cpp_test();
  59. usleep(0);
  60. GC_gcollect();
  62. GC_finalize_all(); // これがないと, すべてのデストラクタが呼び出されるとは限
  63. // らない.
  64. return 0;
  65. }

単純に new Hoge[100] とすると、ガベージコレクト時に、2番目以降のそれぞれの要素についてデストラクタが呼び出されない。C++ の作り上, new[] メソッドには必要メモリしか渡されないため、いかんともしがたい。

上の例では, placement new構文を使って, ファイナライザを明示的に指定し、さらにファイナライザ内でデストラクタを呼び出すようにしている。一応、各要素についてデストラクタを呼び出すことができるが、この方法は、まったくポータブルではない。

配列の各要素についてデストラクタを呼ぶには

配列を生成する場合は、次のように書くしかないように思う。配列の配列にしてしまって、一つずつオブジェクトを生成する。ダサい。 

 26| void cpp_test() {
 27|     Hoge** ary;
 28|     for (int i = 0; i < 5; i++) {
 29|         ary = new (GC) Hoge*[2];
 30|         ary[0] = new Hoge;
 31|         ary[1] = new Hoge;
 32|     }
 33|     ary = NULL; // test
 34| }

最初に戻って、ガベージコレクタを使うからには、デスクトラクタに依存しないように組み立てるほうが良さそうだ。

リンク

サイト内関連文書:

外部: