libphobos/testsuite/libphobos.init_fini/custom_gc.d

   1 import core.gc.registry;
   2 import core.gc.gcinterface;
   3 import core.stdc.stdlib;
   4
   5 static import core.memory;
   6
   7 extern (C) __gshared string[] rt_options = ["gcopt=gc:malloc"];
   8
   9 extern (C) pragma(crt_constructor) void register_mygc()
  10 {
  11     registerGCFactory("malloc", &MallocGC.initialize);
  12 }
  13
  14 extern (C) void register_default_gcs()
  15 {
  16     // remove default GCs
  17 }
  18
  19 /** Simple GC that requires any pointers passed to it's API
  20     to point to start of the allocation.
  21  */
  22 class MallocGC : GC
  23 {
  24 nothrow @nogc:
  25     static GC initialize()
  26     {
  27         import core.stdc.string : memcpy;
  28
  29         __gshared align(__traits(classInstanceAlignment, MallocGC))
  30             ubyte[__traits(classInstanceSize, MallocGC)] buf;
  31
  32         auto init = typeid(MallocGC).initializer();
  33         assert(init.length == buf.length);
  34         auto instance = cast(MallocGC) memcpy(buf.ptr, init.ptr, init.length);
  35         instance.__ctor();
  36         return instance;
  37     }
  38
  39     this()
  40     {
  41     }
  42
  43     void Dtor()
  44     {
  45     }
  46
  47     void enable()
  48     {
  49     }
  50
  51     void disable()
  52     {
  53     }
  54
  55     void collect() nothrow
  56     {
  57     }
  58
  59     void collectNoStack() nothrow
  60     {
  61     }
  62
  63     void minimize() nothrow
  64     {
  65     }
  66
  67     uint getAttr(void* p) nothrow
  68     {
  69         return 0;
  70     }
  71
  72     uint setAttr(void* p, uint mask) nothrow
  73     {
  74         return mask;
  75     }
  76
  77     uint clrAttr(void* p, uint mask) nothrow
  78     {
  79         return mask;
  80     }
  81
  82     void* malloc(size_t size, uint bits, const TypeInfo ti) nothrow
  83     {
  84         return sentinelAdd(.malloc(size + sentinelSize), size);
  85     }
  86
  87     BlkInfo qalloc(size_t size, uint bits, const scope TypeInfo ti) nothrow
  88     {
  89         return BlkInfo(malloc(size, bits, ti), size);
  90     }
  91
  92     void* calloc(size_t size, uint bits, const TypeInfo ti) nothrow
  93     {
  94         return sentinelAdd(.calloc(1, size + sentinelSize), size);
  95     }
  96
  97     void* realloc(void* p, size_t size, uint bits, const TypeInfo ti) nothrow
  98     {
  99         return sentinelAdd(.realloc(p - sentinelSize, size + sentinelSize), size);
 100     }
 101
 102     size_t extend(void* p, size_t minsize, size_t maxsize, const TypeInfo ti) nothrow
 103     {
 104         return 0;
 105     }
 106
 107     size_t reserve(size_t size) nothrow
 108     {
 109         return 0;
 110     }
 111
 112     void free(void* p) nothrow
 113     {
 114         free(p - sentinelSize);
 115     }
 116
 117     void* addrOf(void* p) nothrow
 118     {
 119         return p;
 120     }
 121
 122     size_t sizeOf(void* p) nothrow
 123     {
 124         return query(p).size;
 125     }
 126
 127     BlkInfo query(void* p) nothrow
 128     {
 129         return p ? BlkInfo(p, sentinelGet(p)) : BlkInfo.init;
 130     }
 131
 132     core.memory.GC.Stats stats() nothrow
 133     {
 134         return core.memory.GC.Stats.init;
 135     }
 136
 137     core.memory.GC.ProfileStats profileStats() nothrow
 138     {
 139         return typeof(return).init;
 140     }
 141
 142     void addRoot(void* p) nothrow @nogc
 143     {
 144     }
 145
 146     void removeRoot(void* p) nothrow @nogc
 147     {
 148     }
 149
 150     @property RootIterator rootIter() @nogc
 151     {
 152         return null;
 153     }
 154
 155     void addRange(void* p, size_t sz, const TypeInfo ti) nothrow @nogc
 156     {
 157     }
 158
 159     void removeRange(void* p) nothrow @nogc
 160     {
 161     }
 162
 163     @property RangeIterator rangeIter() @nogc
 164     {
 165         return null;
 166     }
 167
 168     void runFinalizers(const scope void[] segment) nothrow
 169     {
 170     }
 171
 172     bool inFinalizer() nothrow
 173     {
 174         return false;
 175     }
 176
 177     ulong allocatedInCurrentThread() nothrow
 178     {
 179         return stats().allocatedInCurrentThread;
 180     }
 181
 182 private:
 183     // doesn't care for alignment
 184     static void* sentinelAdd(void* p, size_t value)
 185     {
 186         *cast(size_t*) p = value;
 187         return p + sentinelSize;
 188     }
 189
 190     static size_t sentinelGet(void* p)
 191     {
 192         return *cast(size_t*)(p - sentinelSize);
 193     }
 194
 195     enum sentinelSize = size_t.sizeof;
 196 }
 197
 198 void main()
 199 {
 200     // test array append cache
 201     char[] s;
 202     foreach (char c; char.min .. char.max + 1)
 203         s ~= c;
 204 }