X-Git-Url: https://git.llucax.com/software/dgc/cdgc.git/blobdiff_plain/561273a63d42eff2a91b348781f1927ec0a6d7c6..28078ce1ede1d2b4535e9f44bde1466c4912a910:/gc/gc.d

diff --git a/gc/gc.d b/gc/gc.d
index e195e25..8cd5609 100644
--- a/gc/gc.d
+++ b/gc/gc.d
@@ -32,7 +32,6 @@ module gc.gc;
 
 //debug = PRINTF;               // turn on printf's
 //debug = COLLECT_PRINTF;       // turn on printf's
-//debug = THREADINVARIANT;      // check thread integrity
 //debug = LOGGING;              // log allocations / frees
 //debug = MEMSTOMP;             // stomp on memory
 //debug = SENTINEL;             // add underrun/overrrun protection
@@ -51,13 +50,8 @@ version = MULTI_THREADED;       // produce multithreaded version
 import gc.bits;
 import gc.stats;
 import gc.alloc;
+import gc.libc;
 
-import cstdlib = tango.stdc.stdlib : calloc, free, malloc, realloc;
-import cstring = tango.stdc.string : memcpy, memmove, memset;
-
-debug(THREADINVARIANT) import tango.stdc.posix.pthread;
-debug(PRINTF) import tango.stdc.posix.pthread : pthread_self, pthread_t;
-debug import tango.stdc.stdio : printf;
 
 version (GNU)
 {
@@ -150,7 +144,7 @@ debug (LOGGING)
         void Dtor()
         {
             if (data)
-                cstdlib.free(data);
+                .free(data);
             data = null;
         }
 
@@ -163,18 +157,18 @@ debug (LOGGING)
                 assert(dim + nentries <= allocdim);
                 if (!data)
                 {
-                    data = cast(Log*)cstdlib.malloc(allocdim * Log.sizeof);
+                    data = cast(Log*) .malloc(allocdim * Log.sizeof);
                     if (!data && allocdim)
                         onOutOfMemoryError();
                 }
                 else
                 {   Log *newdata;
 
-                    newdata = cast(Log*)cstdlib.malloc(allocdim * Log.sizeof);
+                    newdata = cast(Log*) .malloc(allocdim * Log.sizeof);
                     if (!newdata && allocdim)
                         onOutOfMemoryError();
-                    cstring.memcpy(newdata, data, dim * Log.sizeof);
-                    cstdlib.free(data);
+                    .memcpy(newdata, data, dim * Log.sizeof);
+                    .free(data);
                     data = newdata;
                 }
             }
@@ -189,7 +183,7 @@ debug (LOGGING)
 
         void remove(size_t i)
         {
-            cstring.memmove(data + i, data + i + 1, (dim - i) * Log.sizeof);
+            .memmove(data + i, data + i + 1, (dim - i) * Log.sizeof);
             dim--;
         }
 
@@ -209,7 +203,7 @@ debug (LOGGING)
         {
             reserve(from.dim - dim);
             assert(from.dim <= allocdim);
-            cstring.memcpy(data, from.data, from.dim * Log.sizeof);
+            .memcpy(data, from.data, from.dim * Log.sizeof);
             dim = from.dim;
         }
     }
@@ -240,7 +234,7 @@ class GC
     void initialize()
     {
         gcLock = GCLock.classinfo;
-        gcx = cast(Gcx*)cstdlib.calloc(1, Gcx.sizeof);
+        gcx = cast(Gcx*) .calloc(1, Gcx.sizeof);
         if (!gcx)
             onOutOfMemoryError();
         gcx.initialize();
@@ -250,30 +244,15 @@ class GC
 
     void Dtor()
     {
-        version (linux)
-        {
-            //debug(PRINTF) printf("Thread %x ", pthread_self());
-            //debug(PRINTF) printf("GC.Dtor()\n");
-        }
-
         if (gcx)
         {
             gcx.Dtor();
-            cstdlib.free(gcx);
+            .free(gcx);
             gcx = null;
         }
     }
 
 
-    invariant
-    {
-        if (gcx)
-        {
-            gcx.thread_Invariant();
-        }
-    }
-
-
     /**
      *
      */
@@ -448,7 +427,6 @@ class GC
 
         //debug(PRINTF) printf("GC::malloc(size = %d, gcx = %p)\n", size, gcx);
         assert(gcx);
-        //debug(PRINTF) printf("gcx.self = %x, pthread_self() = %x\n", gcx.self, pthread_self());
 
         size += SENTINEL_EXTRA;
 
@@ -502,9 +480,9 @@ class GC
             // Return next item from free list
             gcx.bucket[bin] = (cast(List*)p).next;
             if( !(bits & BlkAttr.NO_SCAN) )
-                cstring.memset(p + size, 0, binsize[bin] - size);
+                .memset(p + size, 0, binsize[bin] - size);
             //debug(PRINTF) printf("\tmalloc => %x\n", p);
-            debug (MEMSTOMP) cstring.memset(p, 0xF0, size);
+            debug (MEMSTOMP) .memset(p, 0xF0, size);
         }
         else
         {
@@ -558,7 +536,7 @@ class GC
 
         //debug(PRINTF) printf("calloc: %x len %d\n", p, len);
         void *p = mallocNoSync(size, bits);
-        cstring.memset(p, 0, size);
+        .memset(p, 0, size);
         return p;
     }
 
@@ -628,7 +606,7 @@ class GC
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);
-                    cstring.memcpy(p2, p, size);
+                    .memcpy(p2, p, size);
                     p = p2;
                 }
             }
@@ -649,7 +627,7 @@ class GC
                     {   // Shrink in place
                         synchronized (gcLock)
                         {
-                            debug (MEMSTOMP) cstring.memset(p + size, 0xF2, psize - size);
+                            debug (MEMSTOMP) .memset(p + size, 0xF2, psize - size);
                             pool.freePages(pagenum + newsz, psz - newsz);
                         }
                         return p;
@@ -663,8 +641,8 @@ class GC
                             {
                                 if (i == pagenum + newsz)
                                 {
-                                    debug (MEMSTOMP) cstring.memset(p + psize, 0xF0, size - psize);
-                                    cstring.memset(&pool.pagetable[pagenum + psz], B_PAGEPLUS, newsz - psz);
+                                    debug (MEMSTOMP) .memset(p + psize, 0xF0, size - psize);
+                                    .memset(&pool.pagetable[pagenum + psz], B_PAGEPLUS, newsz - psz);
                                     return p;
                                 }
                                 if (i == pool.ncommitted)
@@ -708,7 +686,7 @@ class GC
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);
-                    cstring.memcpy(p2, p, size);
+                    .memcpy(p2, p, size);
                     p = p2;
                 }
             }
@@ -789,8 +767,8 @@ class GC
         }
         else
             return 0;
-        debug (MEMSTOMP) cstring.memset(p + psize, 0xF0, (psz + sz) * PAGESIZE - psize);
-        cstring.memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);
+        debug (MEMSTOMP) .memset(p + psize, 0xF0, (psz + sz) * PAGESIZE - psize);
+        .memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);
         gcx.p_cache = null;
         gcx.size_cache = 0;
         return (psz + sz) * PAGESIZE;
@@ -883,14 +861,14 @@ class GC
             n = pagenum;
             while (++n < pool.ncommitted && pool.pagetable[n] == B_PAGEPLUS)
                 npages++;
-            debug (MEMSTOMP) cstring.memset(p, 0xF2, npages * PAGESIZE);
+            debug (MEMSTOMP) .memset(p, 0xF2, npages * PAGESIZE);
             pool.freePages(pagenum, npages);
         }
         else
         {   // Add to free list
             List *list = cast(List*)p;
 
-            debug (MEMSTOMP) cstring.memset(p, 0xF2, binsize[bin]);
+            debug (MEMSTOMP) .memset(p, 0xF2, binsize[bin]);
 
             list.next = gcx.bucket[bin];
             gcx.bucket[bin] = list;
@@ -1307,7 +1285,7 @@ class GC
         size_t bsize = 0;
 
         //debug(PRINTF) printf("getStats()\n");
-        cstring.memset(&stats, 0, GCStats.sizeof);
+        .memset(&stats, 0, GCStats.sizeof);
 
         for (n = 0; n < gcx.npools; n++)
         {   Pool *pool = gcx.pooltable[n];
@@ -1396,20 +1374,6 @@ const uint notbinsize[B_MAX] = [ ~(16u-1),~(32u-1),~(64u-1),~(128u-1),~(256u-1),
 
 struct Gcx
 {
-    debug (THREADINVARIANT)
-    {
-        pthread_t self;
-        void thread_Invariant()
-        {
-            if (self != pthread_self())
-                printf("thread_Invariant(): gcx = %x, self = %x, pthread_self() = %x\n", this, self, pthread_self());
-            assert(self == pthread_self());
-        }
-    }
-    else
-    {
-        void thread_Invariant() { }
-    }
 
     void *p_cache;
     size_t size_cache;
@@ -1444,8 +1408,6 @@ struct Gcx
         (cast(byte*)this)[0 .. Gcx.sizeof] = 0;
         stackBottom = cast(char*)&dummy;
         log_init();
-        debug (THREADINVARIANT)
-            self = pthread_self();
         //printf("gcx = %p, self = %x\n", this, self);
         inited = 1;
     }
@@ -1459,16 +1421,16 @@ struct Gcx
         {   Pool *pool = pooltable[i];
 
             pool.Dtor();
-            cstdlib.free(pool);
+            .free(pool);
         }
         if (pooltable)
-            cstdlib.free(pooltable);
+            .free(pooltable);
 
         if (roots)
-            cstdlib.free(roots);
+            .free(roots);
 
         if (ranges)
-            cstdlib.free(ranges);
+            .free(ranges);
     }
 
 
@@ -1482,9 +1444,6 @@ struct Gcx
         //printf("Gcx.invariant(): this = %p\n", this);
             size_t i;
 
-            // Assure we're called on the right thread
-            debug (THREADINVARIANT) assert(self == pthread_self());
-
             for (i = 0; i < npools; i++)
             {   Pool *pool = pooltable[i];
 
@@ -1542,12 +1501,12 @@ struct Gcx
             size_t newdim = rootdim * 2 + 16;
             void** newroots;
 
-            newroots = cast(void**)cstdlib.malloc(newdim * newroots[0].sizeof);
+            newroots = cast(void**) .malloc(newdim * newroots[0].sizeof);
             if (!newroots)
                 onOutOfMemoryError();
             if (roots)
-            {   cstring.memcpy(newroots, roots, nroots * newroots[0].sizeof);
-                cstdlib.free(roots);
+            {   .memcpy(newroots, roots, nroots * newroots[0].sizeof);
+                .free(roots);
             }
             roots = newroots;
             rootdim = newdim;
@@ -1567,7 +1526,7 @@ struct Gcx
             if (roots[i] == p)
             {
                 nroots--;
-                cstring.memmove(roots + i, roots + i + 1, (nroots - i) * roots[0].sizeof);
+                .memmove(roots + i, roots + i + 1, (nroots - i) * roots[0].sizeof);
                 return;
             }
         }
@@ -1580,19 +1539,19 @@ struct Gcx
      */
     void addRange(void *pbot, void *ptop)
     {
-        debug(PRINTF) printf("Thread %x ", pthread_self());
-        debug(PRINTF) printf("%x.Gcx::addRange(%x, %x), nranges = %d\n", this, pbot, ptop, nranges);
+        debug (PRINTF) printf("%x.Gcx::addRange(%x, %x), nranges = %d\n", this,
+                pbot, ptop, nranges);
         if (nranges == rangedim)
         {
             size_t newdim = rangedim * 2 + 16;
             Range *newranges;
 
-            newranges = cast(Range*)cstdlib.malloc(newdim * newranges[0].sizeof);
+            newranges = cast(Range*) .malloc(newdim * newranges[0].sizeof);
             if (!newranges)
                 onOutOfMemoryError();
             if (ranges)
-            {   cstring.memcpy(newranges, ranges, nranges * newranges[0].sizeof);
-                cstdlib.free(ranges);
+            {   .memcpy(newranges, ranges, nranges * newranges[0].sizeof);
+                .free(ranges);
             }
             ranges = newranges;
             rangedim = newdim;
@@ -1608,14 +1567,14 @@ struct Gcx
      */
     void removeRange(void *pbot)
     {
-        debug(PRINTF) printf("Thread %x ", pthread_self());
-        debug(PRINTF) printf("%x.Gcx.removeRange(%x), nranges = %d\n", this, pbot, nranges);
+        debug (PRINTF) printf("%x.Gcx.removeRange(%x), nranges = %d\n", this,
+                pbot, nranges);
         for (size_t i = nranges; i--;)
         {
             if (ranges[i].pbot == pbot)
             {
                 nranges--;
-                cstring.memmove(ranges + i, ranges + i + 1, (nranges - i) * ranges[0].sizeof);
+                .memmove(ranges + i, ranges + i + 1, (nranges - i) * ranges[0].sizeof);
                 return;
             }
         }
@@ -1883,8 +1842,8 @@ struct Gcx
                 continue;
             }
             pool.Dtor();
-            cstdlib.free(pool);
-            cstring.memmove(pooltable + n,
+            .free(pool);
+            .memmove(pooltable + n,
                             pooltable + n + 1,
                             (--npools - n) * (Pool*).sizeof);
             minAddr = pooltable[0].baseAddr;
@@ -1967,10 +1926,10 @@ struct Gcx
       L1:
         pool.pagetable[pn] = B_PAGE;
         if (npages > 1)
-            cstring.memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
+            .memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
         p = pool.baseAddr + pn * PAGESIZE;
-        cstring.memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
-        debug (MEMSTOMP) cstring.memset(p, 0xF1, size);
+        .memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
+        debug (MEMSTOMP) .memset(p, 0xF1, size);
         //debug(PRINTF) printf("\tp = %x\n", p);
         return p;
 
@@ -2018,7 +1977,7 @@ struct Gcx
                 npages = n;
         }
 
-        pool = cast(Pool *)cstdlib.calloc(1, Pool.sizeof);
+        pool = cast(Pool *) .calloc(1, Pool.sizeof);
         if (pool)
         {
             pool.initialize(npages);
@@ -2026,7 +1985,7 @@ struct Gcx
                 goto Lerr;
 
             newnpools = npools + 1;
-            newpooltable = cast(Pool **)cstdlib.realloc(pooltable, newnpools * (Pool *).sizeof);
+            newpooltable = cast(Pool **) .realloc(pooltable, newnpools * (Pool *).sizeof);
             if (!newpooltable)
                 goto Lerr;
 
@@ -2036,7 +1995,7 @@ struct Gcx
                 if (pool.opCmp(newpooltable[i]) < 0)
                      break;
             }
-            cstring.memmove(newpooltable + i + 1, newpooltable + i, (npools - i) * (Pool *).sizeof);
+            .memmove(newpooltable + i + 1, newpooltable + i, (npools - i) * (Pool *).sizeof);
             newpooltable[i] = pool;
 
             pooltable = newpooltable;
@@ -2049,7 +2008,7 @@ struct Gcx
 
       Lerr:
         pool.Dtor();
-        cstdlib.free(pool);
+        .free(pool);
         return null;
     }
 
@@ -2441,7 +2400,7 @@ struct Gcx
                             //debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 
-                            debug (MEMSTOMP) cstring.memset(p, 0xF3, size);
+                            debug (MEMSTOMP) .memset(p, 0xF3, size);
                         }
                         pool.pagetable[pn] = B_FREE;
                         freed += PAGESIZE;
@@ -2464,7 +2423,7 @@ struct Gcx
                             debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 
-                            debug (MEMSTOMP) cstring.memset(p, 0xF3, size);
+                            debug (MEMSTOMP) .memset(p, 0xF3, size);
 
                             freed += size;
                         }
@@ -2485,7 +2444,7 @@ struct Gcx
                         log_free(sentinel_add(p));
                         pool.pagetable[pn] = B_FREE;
                         freedpages++;
-                        debug (MEMSTOMP) cstring.memset(p, 0xF3, PAGESIZE);
+                        debug (MEMSTOMP) .memset(p, 0xF3, PAGESIZE);
                         while (pn + 1 < ncommitted && pool.pagetable[pn + 1] == B_PAGEPLUS)
                         {
                             pn++;
@@ -2494,7 +2453,7 @@ struct Gcx
 
                             debug (MEMSTOMP)
                             {   p += PAGESIZE;
-                                cstring.memset(p, 0xF3, PAGESIZE);
+                                .memset(p, 0xF3, PAGESIZE);
                             }
                         }
                     }
@@ -2813,10 +2772,10 @@ struct Pool
         freebits.alloc(cast(size_t)poolsize / 16);
         noscan.alloc(cast(size_t)poolsize / 16);
 
-        pagetable = cast(ubyte*)cstdlib.malloc(npages);
+        pagetable = cast(ubyte*) .malloc(npages);
         if (!pagetable)
             onOutOfMemoryError();
-        cstring.memset(pagetable, B_UNCOMMITTED, npages);
+        .memset(pagetable, B_UNCOMMITTED, npages);
 
         this.npages = npages;
         ncommitted = 0;
@@ -2847,7 +2806,7 @@ struct Pool
             topAddr = null;
         }
         if (pagetable)
-            cstdlib.free(pagetable);
+            .free(pagetable);
 
         mark.Dtor();
         scan.Dtor();
@@ -2928,7 +2887,7 @@ struct Pool
             //fflush(stdout);
             if (os_mem_commit(baseAddr, ncommitted * PAGESIZE, tocommit * PAGESIZE) == 0)
             {
-                cstring.memset(pagetable + ncommitted, B_FREE, tocommit);
+                .memset(pagetable + ncommitted, B_FREE, tocommit);
                 auto i = ncommitted;
                 ncommitted += tocommit;
 
@@ -2949,7 +2908,7 @@ struct Pool
      */
     void freePages(size_t pagenum, size_t npages)
     {
-        cstring.memset(&pagetable[pagenum], B_FREE, npages);
+        .memset(&pagetable[pagenum], B_FREE, npages);
     }