rt/gc/cdgc/iface.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 module rt.gc.cdgc.iface;
  28
  29 import rt.gc.cdgc.gc: GC, BlkInfo;
  30 import rt.gc.cdgc.stats: GCStats;
  31
  32 import cstdlib = tango.stdc.stdlib;
  33
  34 version=GCCLASS;
  35
  36 version (GCCLASS)
  37     alias GC gc_t;
  38 else
  39     alias GC* gc_t;
  40
  41 gc_t _gc;
  42
  43 private int _termCleanupLevel=1;
  44
  45 /// sets the cleanup level done by gc
  46 /// (0: none, 1: fullCollect, 2: fullCollectNoStack (might crash daemonThreads))
  47 /// result !=0 if the value was invalid
  48 extern (C) int gc_setTermCleanupLevel(int cLevel){
  49     if (cLevel<0 || cLevel>2) return cLevel;
  50     _termCleanupLevel=cLevel;
  51     return 0;
  52 }
  53
  54 /// returns the cleanup level done by gc
  55 extern (C) int gc_getTermCleanupLevel(){
  56     return _termCleanupLevel;
  57 }
  58
  59 version (DigitalMars) version(OSX) {
  60     extern(C) void _d_osx_image_init();
  61 }
  62
  63 extern (C) void thread_init();
  64
  65 extern (C) void gc_init()
  66 {
  67     version (GCCLASS)
  68     {
  69         ClassInfo ci = GC.classinfo;
  70         void* p = cstdlib.malloc(ci.init.length);
  71         (cast(byte*)p)[0 .. ci.init.length] = ci.init[];
  72         _gc = cast(GC)p;
  73     }
  74     else
  75     {
  76         _gc = cast(GC*) cstdlib.calloc(1, GC.sizeof);
  77     }
  78     _gc.initialize();
  79     version (DigitalMars) version(OSX) {
  80         _d_osx_image_init();
  81     }
  82     // NOTE: The GC must initialize the thread library
  83     //       before its first collection.
  84     thread_init();
  85 }
  86
  87 extern (C) void gc_term()
  88 {
  89     if (_termCleanupLevel<1) {
  90         // no cleanup
  91     } else if (_termCleanupLevel==2){
  92         // a more complete cleanup
  93         // NOTE: There may be daemons threads still running when this routine is
  94         //       called.  If so, cleaning memory out from under then is a good
  95         //       way to make them crash horribly.
  96         //       Often this probably doesn't matter much since the app is
  97         //       supposed to be shutting down anyway, but for example tests might
  98         //       crash (and be considerd failed even if the test was ok).
  99         //       thus this is not the default and should be enabled by
 100         //       I'm disabling cleanup for now until I can think about it some
 101         //       more.
 102         //
 103         _gc.fullCollectNoStack(); // not really a 'collect all' -- still scans
 104                                   // static data area, roots, and ranges.
 105         _gc.Dtor();
 106     } else {
 107         // default (safe) clenup
 108         _gc.fullCollect();
 109     }
 110 }
 111
 112 extern (C) void gc_enable()
 113 {
 114     _gc.enable();
 115 }
 116
 117 extern (C) void gc_disable()
 118 {
 119     _gc.disable();
 120 }
 121
 122 extern (C) void gc_collect()
 123 {
 124     _gc.fullCollect();
 125 }
 126
 127
 128 extern (C) void gc_minimize()
 129 {
 130     _gc.minimize();
 131 }
 132
 133 extern (C) uint gc_getAttr( void* p )
 134 {
 135     return _gc.getAttr( p );
 136 }
 137
 138 extern (C) uint gc_setAttr( void* p, uint a )
 139 {
 140     return _gc.setAttr( p, a );
 141 }
 142
 143 extern (C) uint gc_clrAttr( void* p, uint a )
 144 {
 145     return _gc.clrAttr( p, a );
 146 }
 147
 148 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
 149 {
 150     return _gc.malloc( sz, ba );
 151 }
 152
 153 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 154 {
 155     return _gc.calloc( sz, ba );
 156 }
 157
 158 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 159 {
 160     return _gc.realloc( p, sz, ba );
 161 }
 162
 163 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 164 {
 165     return _gc.extend( p, mx, sz );
 166 }
 167
 168 extern (C) size_t gc_reserve( size_t sz )
 169 {
 170     return _gc.reserve( sz );
 171 }
 172
 173 extern (C) void gc_free( void* p )
 174 {
 175     _gc.free( p );
 176 }
 177
 178 extern (C) void* gc_addrOf( void* p )
 179 {
 180     return _gc.addrOf( p );
 181 }
 182
 183 extern (C) size_t gc_sizeOf( void* p )
 184 {
 185     return _gc.sizeOf( p );
 186 }
 187
 188 extern (C) BlkInfo gc_query( void* p )
 189 {
 190     return _gc.query( p );
 191 }
 192
 193 // NOTE: This routine is experimental.  The stats or function name may change
 194 //       before it is made officially available.
 195 extern (C) GCStats gc_stats()
 196 {
 197     GCStats stats = void;
 198     _gc.getStats( stats );
 199     return stats;
 200 }
 201
 202 extern (C) void gc_addRoot( void* p )
 203 {
 204     _gc.addRoot( p );
 205 }
 206
 207 extern (C) void gc_addRange( void* p, size_t sz )
 208 {
 209     _gc.addRange( p, sz );
 210 }
 211
 212 extern (C) void gc_removeRoot( void *p )
 213 {
 214     _gc.removeRoot( p );
 215 }
 216
 217 extern (C) void gc_removeRange( void *p )
 218 {
 219     _gc.removeRange( p );
 220 }
 221
 222 extern (C) void* gc_weakpointerCreate( Object r )
 223 {
 224     return _gc.weakpointerCreate(r);
 225 }
 226
 227 extern (C) void gc_weakpointerDestroy( void* wp )
 228 {
 229     _gc.weakpointerDestroy(wp);
 230 }
 231
 232 extern (C) Object gc_weakpointerGet( void* wp )
 233 {
 234     return _gc.weakpointerGet(wp);
 235 }
 236
 237
 238 // vim: set et sw=4 sts=4 :