iface.d

   1 /**
   2  * This module contains a minimal garbage collector implementation according to
   3  * Tango requirements.  This library is mostly intended to serve as an example,
   4  * but it is usable in applications which do not rely on a garbage collector
   5  * to clean up memory (ie. when dynamic array resizing is not used, and all
   6  * memory allocated with 'new' is freed deterministically with 'delete').
   7  *
   8  * Please note that block attribute data must be tracked, or at a minimum, the
   9  * FINALIZE bit must be tracked for any allocated memory block because calling
  10  * rt_finalize on a non-object block can result in an access violation.  In the
  11  * allocator below, this tracking is done via a leading uint bitmask.  A real
  12  * allocator may do better to store this data separately, similar to the basic
  13  * GC normally used by Tango.
  14  *
  15  * Copyright: Public Domain
  16  * License:   BOLA
  17  * Authors:   Leandro Lucarella
  18  */
  19
  20 module iface;
  21
  22 private {
  23
  24     import gc: NaiveGC, BlkInfo;
  25
  26     import tango.stdc.stdlib;
  27     debug (gc_naive_iface) import tango.stdc.stdio;
  28
  29     NaiveGC gc;
  30
  31     class GCLock {} // TODO
  32
  33 }
  34
  35 extern (C) void gc_init()
  36 {
  37     debug (gc_naive_iface) printf("gc_init()\n");
  38     gc.init();
  39 }
  40
  41 extern (C) void gc_term()
  42 {
  43     debug (gc_naive_iface) printf("gc_term()\n");
  44     gc.term();
  45 }
  46
  47 extern (C) void gc_enable()
  48 {
  49     debug (gc_naive_iface) printf("gc_enable()\n");
  50     gc.enable();
  51 }
  52
  53 extern (C) void gc_disable()
  54 {
  55     debug (gc_naive_iface) printf("gc_disable()\n");
  56     gc.disable();
  57 }
  58
  59 extern (C) void gc_collect()
  60 {
  61     debug (gc_naive_iface) printf("gc_collect()\n");
  62     gc.collect();
  63 }
  64
  65 extern (C) void gc_minimize()
  66 {
  67     debug (gc_naive_iface) printf("gc_minimize()\n");
  68     gc.minimize();
  69 }
  70
  71 extern (C) uint gc_getAttr(void* ptr)
  72 {
  73     debug (gc_naive_iface) printf("gc_getAttr(%p)\n", ptr);
  74     return gc.getAttr(ptr);
  75 }
  76
  77 // return the old value
  78 extern (C) uint gc_setAttr(void* ptr, uint attr)
  79 {
  80     debug (gc_naive_iface) printf("gc_setAttr(%p, %u)\n", ptr, attr);
  81     return gc.setAttr(ptr, attr);
  82 }
  83
  84 extern (C) uint gc_clrAttr(void* ptr, uint attr)
  85 {
  86     debug (gc_naive_iface) printf("gc_clrAttr(%p, %u)\n", ptr, attr);
  87     return gc.clrAttr(ptr, attr);
  88 }
  89
  90 extern (C) void* gc_malloc(size_t size, uint attr=0)
  91 {
  92     debug (gc_naive_iface) printf("gc_malloc(%u, %u)\n", size, attr);
  93     auto p = gc.malloc(size, attr);
  94     debug (gc_naive_iface) printf("gc_malloc() -> %p\n", p);
  95     return p;
  96 }
  97
  98 extern (C) void* gc_calloc(size_t size, uint attr=0)
  99 {
 100     debug (gc_naive_iface) printf("gc_calloc(%u, %u)\n", size, attr);
 101     return gc.calloc(size, attr);
 102 }
 103
 104 extern (C) void* gc_realloc(void* ptr, size_t size, uint attr=0)
 105 {
 106     debug (gc_naive_iface) printf("gc_realloc(%p, %u, %u)\n", ptr, size, attr);
 107     return gc.realloc(ptr, size, attr);
 108 }
 109
 110 extern (C) size_t gc_extend(void* ptr, size_t min_size, size_t max_size)
 111 {
 112     debug (gc_naive_iface)
 113         printf("gc_extend(%p, %u, %u)\n", ptr, min_size, max_size);
 114     return gc.extend(ptr, min_size, max_size);
 115 }
 116
 117 extern (C) size_t gc_reserve(size_t size)
 118 {
 119     debug (gc_naive_iface) printf("gc_reserve(%u)\n", size);
 120     return gc.reserve(size);
 121 }
 122
 123 extern (C) void gc_free(void* ptr)
 124 {
 125     debug (gc_naive_iface) printf("gc_free(%p)\n", ptr);
 126     gc.free(ptr);
 127 }
 128
 129 extern (C) void* gc_addrOf(void* ptr)
 130 {
 131     debug (gc_naive_iface) printf("gc_addrOf(%p)\n", ptr);
 132     return gc.addrOf(ptr);
 133 }
 134
 135 // TODO: acepta un address que no sea el base?
 136 //       es valido aceptar un ptr que no pertenezca al heap?
 137 extern (C) size_t gc_sizeOf(void* ptr)
 138 {
 139     debug (gc_naive_iface) printf("gc_sizeOf(%p)\n", ptr);
 140     return gc.sizeOf(ptr);
 141 }
 142
 143 // TODO: acepta un address que no sea el base?
 144 //       es valido aceptar un ptr que no pertenezca al heap?
 145 extern (C) BlkInfo gc_query(void* ptr)
 146 {
 147     debug (gc_naive_iface) printf("gc_query(%p)\n", ptr);
 148     return gc.query(ptr);
 149 }
 150
 151 extern (C) void gc_addRoot(void* ptr)
 152 {
 153     debug (gc_naive_iface) printf("gc_addRoot(%p)\n", ptr);
 154     gc.addRoot(ptr);
 155 }
 156
 157 extern (C) void gc_addRange(void* ptr, size_t size)
 158 {
 159     debug (gc_naive_iface) printf("gc_addRange(%p, %u)\n", ptr, size);
 160     gc.addRange(ptr, size);
 161 }
 162
 163 extern (C) void gc_removeRoot(void* ptr)
 164 {
 165     debug (gc_naive_iface) printf("gc_removeRoot(%p)\n", ptr);
 166     gc.removeRoot(ptr);
 167 }
 168
 169 extern (C) void gc_removeRange(void* ptr)
 170 {
 171     debug (gc_naive_iface) printf("gc_removeRange(%p)\n", ptr);
 172     gc.removeRange(ptr);
 173 }
 174
 175 // vim: set et sw=4 sts=4 :