src/gc/basic/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 private import gcx;
  28 private import gcstats;
  29 private import 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 extern (C) void thread_init();
  41
  42 extern (C) void gc_init()
  43 {
  44     version (GCCLASS)
  45     {   void* p;
  46         ClassInfo ci = GC.classinfo;
  47
  48         p = malloc(ci.init.length);
  49         (cast(byte*)p)[0 .. ci.init.length] = ci.init[];
  50         _gc = cast(GC)p;
  51     }
  52     else
  53     {
  54         _gc = cast(GC*) calloc(1, GC.sizeof);
  55     }
  56     _gc.initialize();
  57     // NOTE: The GC must initialize the thread library
  58     //       before its first collection.
  59     thread_init();
  60 }
  61
  62 extern (C) void gc_term()
  63 {
  64     // NOTE: There may be daemons threads still running when this routine is
  65     //       called.  If so, cleaning memory out from under then is a good
  66     //       way to make them crash horribly.  This probably doesn't matter
  67     //       much since the app is supposed to be shutting down anyway, but
  68     //       I'm disabling cleanup for now until I can think about it some
  69     //       more.
  70     //
  71     // NOTE: Due to popular demand, this has been re-enabled.  It still has
  72     //       the problems mentioned above though, so I guess we'll see.
  73     _gc.fullCollectNoStack(); // not really a 'collect all' -- still scans
  74                               // static data area, roots, and ranges.
  75     _gc.Dtor();
  76 }
  77
  78 extern (C) void gc_enable()
  79 {
  80     _gc.enable();
  81 }
  82
  83 extern (C) void gc_disable()
  84 {
  85     _gc.disable();
  86 }
  87
  88 extern (C) void gc_collect()
  89 {
  90     _gc.fullCollect();
  91 }
  92
  93
  94 extern (C) void gc_minimize()
  95 {
  96     _gc.minimize();
  97 }
  98
  99 extern (C) uint gc_getAttr( void* p )
 100 {
 101     return _gc.getAttr( p );
 102 }
 103
 104 extern (C) uint gc_setAttr( void* p, uint a )
 105 {
 106     return _gc.setAttr( p, a );
 107 }
 108
 109 extern (C) uint gc_clrAttr( void* p, uint a )
 110 {
 111     return _gc.clrAttr( p, a );
 112 }
 113
 114 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
 115 {
 116     return _gc.malloc( sz, ba );
 117 }
 118
 119 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 120 {
 121     return _gc.calloc( sz, ba );
 122 }
 123
 124 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 125 {
 126     return _gc.realloc( p, sz, ba );
 127 }
 128
 129 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 130 {
 131     return _gc.extend( p, mx, sz );
 132 }
 133
 134 extern (C) size_t gc_reserve( size_t sz )
 135 {
 136     return _gc.reserve( sz );
 137 }
 138
 139 extern (C) void gc_free( void* p )
 140 {
 141     _gc.free( p );
 142 }
 143
 144 extern (C) void* gc_addrOf( void* p )
 145 {
 146     return _gc.addrOf( p );
 147 }
 148
 149 extern (C) size_t gc_sizeOf( void* p )
 150 {
 151     return _gc.sizeOf( p );
 152 }
 153
 154 extern (C) BlkInfo gc_query( void* p )
 155 {
 156     return _gc.query( p );
 157 }
 158
 159 // NOTE: This routine is experimental.  The stats or function name may change
 160 //       before it is made officially available.
 161 extern (C) GCStats gc_stats()
 162 {
 163     GCStats stats = void;
 164     _gc.getStats( stats );
 165     return stats;
 166 }
 167
 168 extern (C) void gc_addRoot( void* p )
 169 {
 170     _gc.addRoot( p );
 171 }
 172
 173 extern (C) void gc_addRange( void* p, size_t sz )
 174 {
 175     _gc.addRange( p, sz );
 176 }
 177
 178 extern (C) void gc_removeRoot( void *p )
 179 {
 180     _gc.removeRoot( p );
 181 }
 182
 183 extern (C) void gc_removeRange( void *p )
 184 {
 185     _gc.removeRange( p );
 186 }