Remove valloc() allocation method

[software/dgc/cdgc.git] / gc / gc.d

diff --git a/gc/gc.d b/gc/gc.d
index e195e2578405b42a21db22e412bdbc05f30a18eb..8cd56095b98dd4d42b08b149097f107f0e7dc405 100644 (file)
--- 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 = 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
 //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.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)
 {
 
 version (GNU)
 {


@@ -150,7 +144,7 @@ debug (LOGGING)
         void Dtor()
         {
             if (data)
         void Dtor()
         {
             if (data)

-                cstdlib.free(data);
+                .free(data);

             data = null;
         }
 
             data = null;
         }
 


@@ -163,18 +157,18 @@ debug (LOGGING)
                 assert(dim + nentries <= allocdim);
                 if (!data)
                 {
                 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;
 
                     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();
                     if (!newdata && allocdim)
                         onOutOfMemoryError();

-                    cstring.memcpy(newdata, data, dim * Log.sizeof);
-                    cstdlib.free(data);
+                    .memcpy(newdata, data, dim * Log.sizeof);
+                    .free(data);

                     data = newdata;
                 }
             }
                     data = newdata;
                 }
             }


@@ -189,7 +183,7 @@ debug (LOGGING)
 
         void remove(size_t i)
         {
 
         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--;
         }
 
             dim--;
         }
 


@@ -209,7 +203,7 @@ debug (LOGGING)
         {
             reserve(from.dim - dim);
             assert(from.dim <= allocdim);
         {
             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;
         }
     }
             dim = from.dim;
         }
     }


@@ -240,7 +234,7 @@ class GC
     void initialize()
     {
         gcLock = GCLock.classinfo;
     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();
         if (!gcx)
             onOutOfMemoryError();
         gcx.initialize();


@@ -250,30 +244,15 @@ class GC
 
     void Dtor()
     {
 
     void Dtor()
     {

-        version (linux)
-        {
-            //debug(PRINTF) printf("Thread %x ", pthread_self());
-            //debug(PRINTF) printf("GC.Dtor()\n");
-        }
-

         if (gcx)
         {
             gcx.Dtor();
         if (gcx)
         {
             gcx.Dtor();

-            cstdlib.free(gcx);
+            .free(gcx);

             gcx = null;
         }
     }
 
 
             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("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;
 
 
         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) )
             // 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(PRINTF) printf("\tmalloc => %x\n", p);

-            debug (MEMSTOMP) cstring.memset(p, 0xF0, size);
+            debug (MEMSTOMP) .memset(p, 0xF0, size);

         }
         else
         {
         }
         else
         {


@@ -558,7 +536,7 @@ class GC
 
         //debug(PRINTF) printf("calloc: %x len %d\n", p, len);
         void *p = mallocNoSync(size, bits);
 
         //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;
     }
 
         return p;
     }
 


@@ -628,7 +606,7 @@ class GC
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);

-                    cstring.memcpy(p2, p, size);
+                    .memcpy(p2, p, size);

                     p = p2;
                 }
             }
                     p = p2;
                 }
             }


@@ -649,7 +627,7 @@ class GC
                     {   // Shrink in place
                         synchronized (gcLock)
                         {
                     {   // 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;
                             pool.freePages(pagenum + newsz, psz - newsz);
                         }
                         return p;


@@ -663,8 +641,8 @@ class GC
                             {
                                 if (i == pagenum + newsz)
                                 {
                             {
                                 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)
                                     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);
                     if (psize < size)
                         size = psize;
                     //debug(PRINTF) printf("\tcopying %d bytes\n",size);

-                    cstring.memcpy(p2, p, size);
+                    .memcpy(p2, p, size);

                     p = p2;
                 }
             }
                     p = p2;
                 }
             }


@@ -789,8 +767,8 @@ class GC
         }
         else
             return 0;
         }
         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;
         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++;
             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;
 
             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;
 
             list.next = gcx.bucket[bin];
             gcx.bucket[bin] = list;


@@ -1307,7 +1285,7 @@ class GC
         size_t bsize = 0;
 
         //debug(PRINTF) printf("getStats()\n");
         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];
 
         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
 {
 
 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;
 
     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();
         (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;
     }
         //printf("gcx = %p, self = %x\n", this, self);
         inited = 1;
     }


@@ -1459,16 +1421,16 @@ struct Gcx
         {   Pool *pool = pooltable[i];
 
             pool.Dtor();
         {   Pool *pool = pooltable[i];
 
             pool.Dtor();

-            cstdlib.free(pool);
+            .free(pool);

         }
         if (pooltable)
         }
         if (pooltable)

-            cstdlib.free(pooltable);
+            .free(pooltable);

 
         if (roots)
 
         if (roots)

-            cstdlib.free(roots);
+            .free(roots);

 
         if (ranges)
 
         if (ranges)

-            cstdlib.free(ranges);
+            .free(ranges);

     }
 
 
     }
 
 


@@ -1482,9 +1444,6 @@ struct Gcx
         //printf("Gcx.invariant(): this = %p\n", this);
             size_t i;
 
         //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];
 
             for (i = 0; i < npools; i++)
             {   Pool *pool = pooltable[i];
 


@@ -1542,12 +1501,12 @@ struct Gcx
             size_t newdim = rootdim * 2 + 16;
             void** newroots;
 
             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)
             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;
             }
             roots = newroots;
             rootdim = newdim;


@@ -1567,7 +1526,7 @@ struct Gcx
             if (roots[i] == p)
             {
                 nroots--;
             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;
             }
         }
                 return;
             }
         }


@@ -1580,19 +1539,19 @@ struct Gcx
      */
     void addRange(void *pbot, void *ptop)
     {
      */
     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;
 
         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)
             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;
             }
             ranges = newranges;
             rangedim = newdim;


@@ -1608,14 +1567,14 @@ struct Gcx
      */
     void removeRange(void *pbot)
     {
      */
     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--;
         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;
             }
         }
                 return;
             }
         }


@@ -1883,8 +1842,8 @@ struct Gcx
                 continue;
             }
             pool.Dtor();
                 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;
                             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)
       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;
         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;
 
         //debug(PRINTF) printf("\tp = %x\n", p);
         return p;
 


@@ -2018,7 +1977,7 @@ struct Gcx
                 npages = n;
         }
 
                 npages = n;
         }
 

-        pool = cast(Pool *)cstdlib.calloc(1, Pool.sizeof);
+        pool = cast(Pool *) .calloc(1, Pool.sizeof);

         if (pool)
         {
             pool.initialize(npages);
         if (pool)
         {
             pool.initialize(npages);


@@ -2026,7 +1985,7 @@ struct Gcx
                 goto Lerr;
 
             newnpools = npools + 1;
                 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;
 
             if (!newpooltable)
                 goto Lerr;
 


@@ -2036,7 +1995,7 @@ struct Gcx
                 if (pool.opCmp(newpooltable[i]) < 0)
                      break;
             }
                 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;
             newpooltable[i] = pool;
 
             pooltable = newpooltable;


@@ -2049,7 +2008,7 @@ struct Gcx
 
       Lerr:
         pool.Dtor();
 
       Lerr:
         pool.Dtor();

-        cstdlib.free(pool);
+        .free(pool);

         return null;
     }
 
         return null;
     }
 


@@ -2441,7 +2400,7 @@ struct Gcx
                             //debug(PRINTF) printf("\tcollecting %x\n", list);
                             log_free(sentinel_add(list));
 
                             //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;
                         }
                         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(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;
                         }
 
                             freed += size;
                         }


@@ -2485,7 +2444,7 @@ struct Gcx
                         log_free(sentinel_add(p));
                         pool.pagetable[pn] = B_FREE;
                         freedpages++;
                         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++;
                         while (pn + 1 < ncommitted && pool.pagetable[pn + 1] == B_PAGEPLUS)
                         {
                             pn++;


@@ -2494,7 +2453,7 @@ struct Gcx
 
                             debug (MEMSTOMP)
                             {   p += PAGESIZE;
 
                             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);
 
         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();
         if (!pagetable)
             onOutOfMemoryError();

-        cstring.memset(pagetable, B_UNCOMMITTED, npages);
+        .memset(pagetable, B_UNCOMMITTED, npages);

 
         this.npages = npages;
         ncommitted = 0;
 
         this.npages = npages;
         ncommitted = 0;


@@ -2847,7 +2806,7 @@ struct Pool
             topAddr = null;
         }
         if (pagetable)
             topAddr = null;
         }
         if (pagetable)

-            cstdlib.free(pagetable);
+            .free(pagetable);

 
         mark.Dtor();
         scan.Dtor();
 
         mark.Dtor();
         scan.Dtor();


@@ -2928,7 +2887,7 @@ struct Pool
             //fflush(stdout);
             if (os_mem_commit(baseAddr, ncommitted * PAGESIZE, tocommit * PAGESIZE) == 0)
             {
             //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;
 
                 auto i = ncommitted;
                 ncommitted += tocommit;
 


@@ -2949,7 +2908,7 @@ struct Pool
      */
     void freePages(size_t pagenum, size_t npages)
     {
      */
     void freePages(size_t pagenum, size_t npages)
     {

-        cstring.memset(&pagetable[pagenum], B_FREE, npages);
+        .memset(&pagetable[pagenum], B_FREE, npages);

     }
 
 
     }