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 private import stdc.stdlib;
  22
  23 private
  24 {
  25    enum BlkAttr : uint
  26     {
  27         FINALIZE = 0b0000_0001,
  28         NO_SCAN  = 0b0000_0010,
  29         NO_MOVE  = 0b0000_0100,
  30         ALL_BITS = 0b1111_1111
  31     }
  32
  33     struct BlkInfo
  34     {
  35         void*  base;
  36         size_t size;
  37         uint   attr;
  38     }
  39
  40     extern (C) void thread_init();
  41     extern (C) void onOutOfMemoryError();
  42 }
  43
  44 extern (C) void gc_init()
  45 {
  46     // NOTE: The GC must initialize the thread library before its first
  47     //       collection, and always before returning from gc_init().
  48     thread_init();
  49 }
  50
  51 extern (C) void gc_term()
  52 {
  53
  54 }
  55
  56 extern (C) void gc_enable()
  57 {
  58
  59 }
  60
  61 extern (C) void gc_disable()
  62 {
  63
  64 }
  65
  66 extern (C) void gc_collect()
  67 {
  68
  69 }
  70
  71 extern (C) void gc_minimize()
  72 {
  73
  74 }
  75
  76 extern (C) uint gc_getAttr( void* p )
  77 {
  78     return 0;
  79 }
  80
  81 extern (C) uint gc_setAttr( void* p, uint a )
  82 {
  83     return 0;
  84 }
  85
  86 extern (C) uint gc_clrAttr( void* p, uint a )
  87 {
  88     return 0;
  89 }
  90
  91 extern (C) void* gc_malloc( size_t sz, uint ba = 0 )
  92 {
  93     void* p = malloc( sz );
  94
  95     if( sz && p is null )
  96         onOutOfMemoryError();
  97     return p;
  98 }
  99
 100 extern (C) void* gc_calloc( size_t sz, uint ba = 0 )
 101 {
 102     void* p = calloc( 1, sz );
 103
 104     if( sz && p is null )
 105         onOutOfMemoryError();
 106     return p;
 107 }
 108
 109 extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 )
 110 {
 111     p = realloc( p, sz );
 112
 113     if( sz && p is null )
 114         onOutOfMemoryError();
 115     return p;
 116 }
 117
 118 extern (C) size_t gc_extend( void* p, size_t mx, size_t sz )
 119 {
 120     return 0;
 121 }
 122
 123 extern (C) size_t gc_reserve( size_t sz )
 124 {
 125     return 0;
 126 }
 127
 128 extern (C) void gc_free( void* p )
 129 {
 130     free( p );
 131 }
 132
 133 extern (C) void* gc_addrOf( void* p )
 134 {
 135     return null;
 136 }
 137
 138 extern (C) size_t gc_sizeOf( void* p )
 139 {
 140     return 0;
 141 }
 142
 143 extern (C) BlkInfo gc_query( void* p )
 144 {
 145     return BlkInfo.init;
 146 }
 147
 148 extern (C) void gc_addRoot( void* p )
 149 {
 150
 151 }
 152
 153 extern (C) void gc_addRange( void* p, size_t sz )
 154 {
 155
 156 }
 157
 158 extern (C) void gc_removeRoot( void *p )
 159 {
 160
 161 }
 162
 163 extern (C) void gc_removeRange( void *p )
 164 {
 165
 166 }