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         PointerMap ptrmap = PointerMap.init)
 149 {
 150     return _gc.malloc(sz, attrs, ptrmap);
 151 }
 152
 153 extern (C) void* gc_calloc(size_t sz, uint attrs = 0,
 154         PointerMap ptrmap = PointerMap.init)
 155 {
 156     return _gc.calloc(sz, attrs, ptrmap);
 157 }
 158
 159 extern (C) void* gc_realloc(void* p, size_t sz, uint attrs = 0,
 160         PointerMap ptrmap = PointerMap.init)
 161 {
 162     return _gc.realloc(p, sz, attrs, ptrmap);
 163 }
 164
 165 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 166 {
 167     return _gc.extend( p, mx, sz );
 168 }
 169
 170 extern (C) size_t gc_reserve( size_t sz )
 171 {
 172     return _gc.reserve( sz );
 173 }
 174
 175 extern (C) void gc_free( void* p )
 176 {
 177     _gc.free( p );
 178 }
 179
 180 extern (C) void* gc_addrOf( void* p )
 181 {
 182     return _gc.addrOf( p );
 183 }
 184
 185 extern (C) size_t gc_sizeOf( void* p )
 186 {
 187     return _gc.sizeOf( p );
 188 }
 189
 190 extern (C) BlkInfo gc_query( void* p )
 191 {
 192     return _gc.query( p );
 193 }
 194
 195 // NOTE: This routine is experimental.  The stats or function name may change
 196 //       before it is made officially available.
 197 extern (C) GCStats gc_stats()
 198 {
 199     GCStats stats = void;
 200     _gc.getStats( stats );
 201     return stats;
 202 }
 203
 204 extern (C) void gc_addRoot( void* p )
 205 {
 206     _gc.addRoot( p );
 207 }
 208
 209 extern (C) void gc_addRange( void* p, size_t sz )
 210 {
 211     _gc.addRange( p, sz );
 212 }
 213
 214 extern (C) void gc_removeRoot( void *p )
 215 {
 216     _gc.removeRoot( p );
 217 }
 218
 219 extern (C) void gc_removeRange( void *p )
 220 {
 221     _gc.removeRange( p );
 222 }
 223
 224 extern (C) void* gc_weakpointerCreate( Object r )
 225 {
 226     return _gc.weakpointerCreate(r);
 227 }
 228
 229 extern (C) void gc_weakpointerDestroy( void* wp )
 230 {
 231     _gc.weakpointerDestroy(wp);
 232 }
 233
 234 extern (C) Object gc_weakpointerGet( void* wp )
 235 {
 236     return _gc.weakpointerGet(wp);
 237 }
 238
 239
 240 // vim: set et sw=4 sts=4 :