src/gc/stub/gc.d

   1 /**
   2  * This module contains a minimal garbage collector implementation according to
   3  * published requirements.  This library is mostly intended to serve as an
   4  * example, but it is usable in applications which do not rely on a garbage
   5  * collector to clean up memory (ie. when dynamic array resizing is not used,
   6  * and all memory allocated with 'new' is freed deterministically with
   7  * 'delete').
   8  *
   9  * Please note that block attribute data must be tracked, or at a minimum, the
  10  * FINALIZE bit must be tracked for any allocated memory block because calling
  11  * rt_finalize on a non-object block can result in an access violation.  In the
  12  * allocator below, this tracking is done via a leading uint bitmask.  A real
  13  * allocator may do better to store this data separately, similar to the basic
  14  * GC.
  15  *
  16  * Copyright: Public Domain
  17  * License:   Public Domain
  18  * Authors:   Sean Kelly
  19  */
  20
  21 module gc.gc;
  22
  23 private
  24 {
  25    import core.stdc.stdlib;
  26
  27    enum BlkAttr : uint
  28     {
  29         FINALIZE = 0b0000_0001,
  30         NO_SCAN  = 0b0000_0010,
  31         NO_MOVE  = 0b0000_0100,
  32         ALL_BITS = 0b1111_1111
  33     }
  34
  35     struct BlkInfo
  36     {
  37         void*  base;
  38         size_t size;
  39         uint   attr;
  40     }
  41
  42     extern (C) void thread_init();
  43     extern (C) void onOutOfMemoryError();
  44
  45     struct Proxy
  46     {
  47         extern (C) void function() gc_enable;
  48         extern (C) void function() gc_disable;
  49         extern (C) void function() gc_collect;
  50         extern (C) void function() gc_minimize;
  51
  52         extern (C) uint function(void*) gc_getAttr;
  53         extern (C) uint function(void*, uint) gc_setAttr;
  54         extern (C) uint function(void*, uint) gc_clrAttr;
  55
  56         extern (C) void*  function(size_t, uint) gc_malloc;
  57         extern (C) void*  function(size_t, uint) gc_calloc;
  58         extern (C) void*  function(void*, size_t, uint ba) gc_realloc;
  59         extern (C) size_t function(void*, size_t, size_t) gc_extend;
  60         extern (C) size_t function(size_t) gc_reserve;
  61         extern (C) void   function(void*) gc_free;
  62
  63         extern (C) void*   function(void*) gc_addrOf;
  64         extern (C) size_t  function(void*) gc_sizeOf;
  65
  66         extern (C) BlkInfo function(void*) gc_query;
  67
  68         extern (C) void function(void*) gc_addRoot;
  69         extern (C) void function(void*, size_t) gc_addRange;
  70
  71         extern (C) void function(void*) gc_removeRoot;
  72         extern (C) void function(void*) gc_removeRange;
  73     }
  74
  75     Proxy  pthis;
  76     Proxy* proxy;
  77
  78     void initProxy()
  79     {
  80         pthis.gc_enable = &gc_enable;
  81         pthis.gc_disable = &gc_disable;
  82         pthis.gc_collect = &gc_collect;
  83         pthis.gc_minimize = &gc_minimize;
  84
  85         pthis.gc_getAttr = &gc_getAttr;
  86         pthis.gc_setAttr = &gc_setAttr;
  87         pthis.gc_clrAttr = &gc_clrAttr;
  88
  89         pthis.gc_malloc = &gc_malloc;
  90         pthis.gc_calloc = &gc_calloc;
  91         pthis.gc_realloc = &gc_realloc;
  92         pthis.gc_extend = &gc_extend;
  93         pthis.gc_reserve = &gc_reserve;
  94         pthis.gc_free = &gc_free;
  95
  96         pthis.gc_addrOf = &gc_addrOf;
  97         pthis.gc_sizeOf = &gc_sizeOf;
  98
  99         pthis.gc_query = &gc_query;
 100
 101         pthis.gc_addRoot = &gc_addRoot;
 102         pthis.gc_addRange = &gc_addRange;
 103
 104         pthis.gc_removeRoot = &gc_removeRoot;
 105         pthis.gc_removeRange = &gc_removeRange;
 106     }
 107
 108     void** roots  = null;
 109     size_t nroots = 0;
 110
 111     struct Range
 112     {
 113         void*  pos;
 114         size_t len;
 115     }
 116
 117     Range* ranges  = null;
 118     size_t nranges = 0;
 119 }
 120
 121 extern (C) void gc_init()
 122 {
 123     // NOTE: The GC must initialize the thread library before its first
 124     //       collection, and always before returning from gc_init().
 125     thread_init();
 126     initProxy();
 127 }
 128
 129 extern (C) void gc_term()
 130 {
 131     free( roots );
 132     free( ranges );
 133 }
 134
 135 extern (C) void gc_enable()
 136 {
 137     if( proxy is null )
 138         return;
 139     return proxy.gc_enable();
 140 }
 141
 142 extern (C) void gc_disable()
 143 {
 144     if( proxy is null )
 145         return;
 146     return proxy.gc_disable();
 147 }
 148
 149 extern (C) void gc_collect()
 150 {
 151     if( proxy is null )
 152         return;
 153     return proxy.gc_collect();
 154 }
 155
 156 extern (C) void gc_minimize()
 157 {
 158     if( proxy is null )
 159         return;
 160     return proxy.gc_minimize();
 161 }
 162
 163 extern (C) uint gc_getAttr( void* p )
 164 {
 165     if( proxy is null )
 166         return 0;
 167     return proxy.gc_getAttr( p );
 168 }
 169
 170 extern (C) uint gc_setAttr( void* p, uint a )
 171 {
 172     if( proxy is null )
 173         return 0;
 174     return proxy.gc_setAttr( p, a );
 175 }
 176
 177 extern (C) uint gc_clrAttr( void* p, uint a )
 178 {
 179     if( proxy is null )
 180         return 0;
 181     return proxy.gc_clrAttr( p, a );
 182 }
 183
 184 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
 185 {
 186     if( proxy is null )
 187     {
 188         void* p = malloc( sz );
 189
 190         if( sz && p is null )
 191             onOutOfMemoryError();
 192         return p;
 193     }
 194     return proxy.gc_malloc( sz, ba );
 195 }
 196
 197 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 198 {
 199     if( proxy is null )
 200     {
 201         void* p = calloc( 1, sz );
 202
 203         if( sz && p is null )
 204             onOutOfMemoryError();
 205         return p;
 206     }
 207     return proxy.gc_calloc( sz, ba );
 208 }
 209
 210 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 211 {
 212     if( proxy is null )
 213     {
 214         p = realloc( p, sz );
 215
 216         if( sz && p is null )
 217             onOutOfMemoryError();
 218         return p;
 219     }
 220     return proxy.gc_realloc( p, sz, ba );
 221 }
 222
 223 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 224 {
 225     if( proxy is null )
 226         return 0;
 227     return proxy.gc_extend( p, mx, sz );
 228 }
 229
 230 extern (C) size_t gc_reserve( size_t sz )
 231 {
 232     if( proxy is null )
 233         return 0;
 234     return proxy.gc_reserve( sz );
 235 }
 236
 237 extern (C) void gc_free( void* p )
 238 {
 239     if( proxy is null )
 240         return free( p );
 241     return proxy.gc_free( p );
 242 }
 243
 244 extern (C) void* gc_addrOf( void* p )
 245 {
 246     if( proxy is null )
 247         return null;
 248     return proxy.gc_addrOf( p );
 249 }
 250
 251 extern (C) size_t gc_sizeOf( void* p )
 252 {
 253     if( proxy is null )
 254         return 0;
 255     return proxy.gc_sizeOf( p );
 256 }
 257
 258 extern (C) BlkInfo gc_query( void* p )
 259 {
 260     if( proxy is null )
 261         return BlkInfo.init;
 262     return proxy.gc_query( p );
 263 }
 264
 265 extern (C) void gc_addRoot( void* p )
 266 {
 267     if( proxy is null )
 268     {
 269         void** r = cast(void**) realloc( roots,
 270                                          (nroots+1) * roots[0].sizeof );
 271         if( r is null )
 272             onOutOfMemoryError();
 273         r[nroots++] = p;
 274         roots = r;
 275
 276     }
 277     return proxy.gc_addRoot( p );
 278 }
 279
 280 extern (C) void gc_addRange( void* p, size_t sz )
 281 {
 282     if( proxy is null )
 283     {
 284         Range* r = cast(Range*) realloc( ranges,
 285                                          (nranges+1) * ranges[0].sizeof );
 286         if( r is null )
 287             onOutOfMemoryError();
 288         r[nranges].pos = p;
 289         r[nranges].len = sz;
 290         ranges = r;
 291         ++nranges;
 292     }
 293     return proxy.gc_addRange( p, sz );
 294 }
 295
 296 extern (C) void gc_removeRoot( void *p )
 297 {
 298     if( proxy is null )
 299     {
 300         for( size_t i = 0; i < nroots; ++i )
 301         {
 302             if( roots[i] is p )
 303             {
 304                 roots[i] = roots[--nroots];
 305                 return;
 306             }
 307         }
 308         assert( false );
 309     }
 310     return proxy.gc_removeRoot( p );
 311 }
 312
 313 extern (C) void gc_removeRange( void *p )
 314 {
 315     if( proxy is null )
 316     {
 317         for( size_t i = 0; i < nranges; ++i )
 318         {
 319             if( ranges[i].pos is p )
 320             {
 321                 ranges[i] = ranges[--nranges];
 322                 return;
 323             }
 324         }
 325         assert( false );
 326     }
 327     return proxy.gc_removeRange( p );
 328 }
 329
 330 extern (C) Proxy* gc_getProxy()
 331 {
 332     return &pthis;
 333 }
 334
 335 export extern (C) void gc_setProxy( Proxy* p )
 336 {
 337     if( proxy !is null )
 338     {
 339         // TODO: Decide if this is an error condition.
 340     }
 341     proxy = p;
 342     foreach( r; roots[0 .. nroots] )
 343         proxy.gc_addRoot( r );
 344     foreach( r; ranges[0 .. nranges] )
 345         proxy.gc_addRange( r.pos, r.len );
 346 }
 347
 348 export extern (C) void gc_clrProxy()
 349 {
 350     foreach( r; ranges[0 .. nranges] )
 351         proxy.gc_removeRange( r.pos );
 352     foreach( r; roots[0 .. nroots] )
 353         proxy.gc_removeRoot( r );
 354     proxy = null;
 355 }