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     } else {
 106         // default (safe) clenup
 107         _gc.fullCollect();
 108     }
 109 }
 110
 111 extern (C) void gc_enable()
 112 {
 113     _gc.enable();
 114 }
 115
 116 extern (C) void gc_disable()
 117 {
 118     _gc.disable();
 119 }
 120
 121 extern (C) void gc_collect()
 122 {
 123     _gc.fullCollect();
 124 }
 125
 126
 127 extern (C) void gc_minimize()
 128 {
 129     _gc.minimize();
 130 }
 131
 132 extern (C) uint gc_getAttr( void* p )
 133 {
 134     return _gc.getAttr( p );
 135 }
 136
 137 extern (C) uint gc_setAttr( void* p, uint a )
 138 {
 139     return _gc.setAttr( p, a );
 140 }
 141
 142 extern (C) uint gc_clrAttr( void* p, uint a )
 143 {
 144     return _gc.clrAttr( p, a );
 145 }
 146
 147 extern (C) void* gc_malloc(size_t sz, uint attrs = 0)
 148 {
 149     return _gc.malloc(sz, attrs);
 150 }
 151
 152 extern (C) void* gc_calloc(size_t sz, uint attrs = 0)
 153 {
 154     return _gc.calloc(sz, attrs);
 155 }
 156
 157 extern (C) void* gc_realloc(void* p, size_t sz, uint attrs = 0)
 158 {
 159     return _gc.realloc(p, sz, attrs);
 160 }
 161
 162 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 163 {
 164     return _gc.extend( p, mx, sz );
 165 }
 166
 167 extern (C) size_t gc_reserve( size_t sz )
 168 {
 169     return _gc.reserve( sz );
 170 }
 171
 172 extern (C) void gc_free( void* p )
 173 {
 174     _gc.free( p );
 175 }
 176
 177 extern (C) void* gc_addrOf( void* p )
 178 {
 179     return _gc.addrOf( p );
 180 }
 181
 182 extern (C) size_t gc_sizeOf( void* p )
 183 {
 184     return _gc.sizeOf( p );
 185 }
 186
 187 extern (C) BlkInfo gc_query( void* p )
 188 {
 189     return _gc.query( p );
 190 }
 191
 192 // NOTE: This routine is experimental.  The stats or function name may change
 193 //       before it is made officially available.
 194 extern (C) GCStats gc_stats()
 195 {
 196     GCStats stats = void;
 197     _gc.getStats( stats );
 198     return stats;
 199 }
 200
 201 extern (C) void gc_addRoot( void* p )
 202 {
 203     _gc.addRoot( p );
 204 }
 205
 206 extern (C) void gc_addRange( void* p, size_t sz )
 207 {
 208     _gc.addRange( p, sz );
 209 }
 210
 211 extern (C) void gc_removeRoot( void *p )
 212 {
 213     _gc.removeRoot( p );
 214 }
 215
 216 extern (C) void gc_removeRange( void *p )
 217 {
 218     _gc.removeRange( p );
 219 }
 220
 221 extern (C) void* gc_weakpointerCreate( Object r )
 222 {
 223     return _gc.weakpointerCreate(r);
 224 }
 225
 226 extern (C) void gc_weakpointerDestroy( void* wp )
 227 {
 228     _gc.weakpointerDestroy(wp);
 229 }
 230
 231 extern (C) Object gc_weakpointerGet( void* wp )
 232 {
 233     return _gc.weakpointerGet(wp);
 234 }
 235
 236
 237 // vim: set et sw=4 sts=4 :