gc.d

   1 /**
   2  * This module contains the garbage collector front-end.
   3  *
   4  * Copyright: Copyright (C) 2005-2006 Digital Mars, www.digitalmars.com.
   5  *            All rights reserved.
   6  * License:
   7  *  This software is provided 'as-is', without any express or implied
   8  *  warranty. In no event will the authors be held liable for any damages
   9  *  arising from the use of this software.
  10  *
  11  *  Permission is granted to anyone to use this software for any purpose,
  12  *  including commercial applications, and to alter it and redistribute it
  13  *  freely, in both source and binary form, subject to the following
  14  *  restrictions:
  15  *
  16  *  o  The origin of this software must not be misrepresented; you must not
  17  *     claim that you wrote the original software. If you use this software
  18  *     in a product, an acknowledgment in the product documentation would be
  19  *     appreciated but is not required.
  20  *  o  Altered source versions must be plainly marked as such, and must not
  21  *     be misrepresented as being the original software.
  22  *  o  This notice may not be removed or altered from any source
  23  *     distribution.
  24  * Authors:   Walter Bright, Sean Kelly
  25  */
  26
  27 import gcx;
  28 import gcstats;
  29 import tango.stdc.stdlib;
  30
  31 version=GCCLASS;
  32
  33 version (GCCLASS)
  34     alias GC gc_t;
  35 else
  36     alias GC* gc_t;
  37
  38 gc_t _gc;
  39
  40 private int _termCleanupLevel=1;
  41
  42 /// sets the cleanup level done by gc
  43 /// (0: none, 1: fullCollect, 2: fullCollectNoStack (might crash daemonThreads))
  44 /// result !=0 if the value was invalid
  45 extern (C) int gc_setTermCleanupLevel(int cLevel){
  46     if (cLevel<0 || cLevel>2) return cLevel;
  47     _termCleanupLevel=cLevel;
  48     return 0;
  49 }
  50
  51 /// returns the cleanup level done by gc
  52 extern (C) int gc_getTermCleanupLevel(){
  53     return _termCleanupLevel;
  54 }
  55
  56 version (DigitalMars) version(OSX) {
  57     extern(C) void _d_osx_image_init();
  58 }
  59
  60 extern (C) void thread_init();
  61
  62 extern (C) void gc_init()
  63 {
  64     version (GCCLASS)
  65     {   void* p;
  66         ClassInfo ci = GC.classinfo;
  67
  68         p = tango.stdc.stdlib.malloc(ci.init.length);
  69         (cast(byte*)p)[0 .. ci.init.length] = ci.init[];
  70         _gc = cast(GC)p;
  71     }
  72     else
  73     {
  74         _gc = cast(GC*) tango.stdc.stdlib.calloc(1, GC.sizeof);
  75     }
  76     _gc.initialize();
  77     version (DigitalMars) version(OSX) {
  78         _d_osx_image_init();
  79     }
  80     // NOTE: The GC must initialize the thread library
  81     //       before its first collection.
  82     thread_init();
  83 }
  84
  85 extern (C) void gc_term()
  86 {
  87     if (_termCleanupLevel<1) {
  88         // no cleanup
  89     } else if (_termCleanupLevel==2){
  90         // a more complete cleanup
  91         // NOTE: There may be daemons threads still running when this routine is
  92         //       called.  If so, cleaning memory out from under then is a good
  93         //       way to make them crash horribly.
  94         //       Often this probably doesn't matter much since the app is
  95         //       supposed to be shutting down anyway, but for example tests might
  96         //       crash (and be considerd failed even if the test was ok).
  97         //       thus this is not the default and should be enabled by
  98         //       I'm disabling cleanup for now until I can think about it some
  99         //       more.
 100         //
 101         _gc.fullCollectNoStack(); // not really a 'collect all' -- still scans
 102                                   // static data area, roots, and ranges.
 103         _gc.Dtor();
 104     } else {
 105         // default (safe) clenup
 106         _gc.fullCollect();
 107     }
 108 }
 109
 110 extern (C) void gc_enable()
 111 {
 112     _gc.enable();
 113 }
 114
 115 extern (C) void gc_disable()
 116 {
 117     _gc.disable();
 118 }
 119
 120 extern (C) void gc_collect()
 121 {
 122     _gc.fullCollect();
 123 }
 124
 125
 126 extern (C) void gc_minimize()
 127 {
 128     _gc.minimize();
 129 }
 130
 131 extern (C) uint gc_getAttr( void* p )
 132 {
 133     return _gc.getAttr( p );
 134 }
 135
 136 extern (C) uint gc_setAttr( void* p, uint a )
 137 {
 138     return _gc.setAttr( p, a );
 139 }
 140
 141 extern (C) uint gc_clrAttr( void* p, uint a )
 142 {
 143     return _gc.clrAttr( p, a );
 144 }
 145
 146 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
 147 {
 148     return _gc.malloc( sz, ba );
 149 }
 150
 151 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 152 {
 153     return _gc.calloc( sz, ba );
 154 }
 155
 156 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 157 {
 158     return _gc.realloc( p, sz, ba );
 159 }
 160
 161 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 162 {
 163     return _gc.extend( p, mx, sz );
 164 }
 165
 166 extern (C) size_t gc_reserve( size_t sz )
 167 {
 168     return _gc.reserve( sz );
 169 }
 170
 171 extern (C) void gc_free( void* p )
 172 {
 173     _gc.free( p );
 174 }
 175
 176 extern (C) void* gc_addrOf( void* p )
 177 {
 178     return _gc.addrOf( p );
 179 }
 180
 181 extern (C) size_t gc_sizeOf( void* p )
 182 {
 183     return _gc.sizeOf( p );
 184 }
 185
 186 extern (C) BlkInfo gc_query( void* p )
 187 {
 188     return _gc.query( p );
 189 }
 190
 191 // NOTE: This routine is experimental.  The stats or function name may change
 192 //       before it is made officially available.
 193 extern (C) GCStats gc_stats()
 194 {
 195     GCStats stats = void;
 196     _gc.getStats( stats );
 197     return stats;
 198 }
 199
 200 extern (C) void gc_addRoot( void* p )
 201 {
 202     _gc.addRoot( p );
 203 }
 204
 205 extern (C) void gc_addRange( void* p, size_t sz )
 206 {
 207     _gc.addRange( p, sz );
 208 }
 209
 210 extern (C) void gc_removeRoot( void *p )
 211 {
 212     _gc.removeRoot( p );
 213 }
 214
 215 extern (C) void gc_removeRange( void *p )
 216 {
 217     _gc.removeRange( p );
 218 }