Change the min_free default to 5%

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

diff --git a/rt/gc/cdgc/gc.d b/rt/gc/cdgc/gc.d
index f70227b5bd5a29c0722594d7a270932d9ad68848..2ec72c4b9ac273a046ca96eef200e5dce60fa5a7 100644 (file)
--- a/rt/gc/cdgc/gc.d
+++ b/rt/gc/cdgc/gc.d
@@ -50,6 +50,8 @@ import opts = rt.gc.cdgc.opts;
 
 import cstdlib = tango.stdc.stdlib;
 import cstring = tango.stdc.string;
 
 import cstdlib = tango.stdc.stdlib;
 import cstring = tango.stdc.string;

+import cstdio = tango.stdc.stdio;
+debug(COLLECT_PRINTF) alias cstdio.printf printf;

 
 /*
  * This is a small optimization that proved it's usefulness. For small chunks
 
 /*
  * This is a small optimization that proved it's usefulness. For small chunks


@@ -97,6 +99,11 @@ package bool has_pointermap(uint attrs)
     return !opts.options.conservative && !(attrs & BlkAttr.NO_SCAN);
 }
 
     return !opts.options.conservative && !(attrs & BlkAttr.NO_SCAN);
 }
 

+private size_t round_up(size_t n, size_t to)
+{
+    return (n + to - 1) / to;
+}
+

 private
 {
     alias void delegate(Object) DEvent;
 private
 {
     alias void delegate(Object) DEvent;


@@ -201,11 +208,19 @@ struct GC
     /// Turn off collections if > 0
     int disabled;
 
     /// Turn off collections if > 0
     int disabled;
 

+    // PID of the fork()ed process doing the mark() (0 if is not running)
+    int mark_proc_pid;
+

     /// min(pool.baseAddr)
     byte *min_addr;
     /// max(pool.topAddr)
     byte *max_addr;
 
     /// min(pool.baseAddr)
     byte *min_addr;
     /// max(pool.topAddr)
     byte *max_addr;
 

+    /// Total heap memory
+    size_t total_mem;
+    /// Free heap memory
+    size_t free_mem;
+

     /// Free list for each size
     List*[B_MAX] free_list;
 
     /// Free list for each size
     List*[B_MAX] free_list;
 


@@ -227,10 +242,19 @@ private T locked(T, alias Code)()
 
 private GC* gc;
 
 
 private GC* gc;
 

+
+bool collect_in_progress()
+{
+    return gc.mark_proc_pid != 0;
+}
+
+

 bool Invariant()
 {
     assert (gc !is null);
     if (gc.inited) {
 bool Invariant()
 {
     assert (gc !is null);
     if (gc.inited) {

+        size_t total_mem = 0;
+        size_t free_mem = 0;

         for (size_t i = 0; i < gc.pools.length; i++) {
             Pool* pool = gc.pools[i];
             pool.Invariant();
         for (size_t i = 0; i < gc.pools.length; i++) {
             Pool* pool = gc.pools[i];
             pool.Invariant();


@@ -240,6 +264,10 @@ bool Invariant()
                 assert(*pool < *gc.pools[i + 1]);
             else if (i + 1 == gc.pools.length)
                 assert(gc.max_addr == pool.topAddr);
                 assert(*pool < *gc.pools[i + 1]);
             else if (i + 1 == gc.pools.length)
                 assert(gc.max_addr == pool.topAddr);

+            total_mem += pool.npages * PAGESIZE;
+            for (size_t pn = 0; pn < pool.npages; ++pn)
+                if (pool.pagetable[pn] == B_FREE)
+                    free_mem += PAGESIZE;

         }
 
         gc.roots.Invariant();
         }
 
         gc.roots.Invariant();


@@ -253,12 +281,17 @@ bool Invariant()
 
         for (size_t i = 0; i < B_PAGE; i++) {
             for (List *list = gc.free_list[i]; list; list = list.next) {
 
         for (size_t i = 0; i < B_PAGE; i++) {
             for (List *list = gc.free_list[i]; list; list = list.next) {

-                assert (list.pool !is null);
+                auto pool = list.pool;
+                assert (pool !is null);

                 auto p = cast(byte*) list;
                 auto p = cast(byte*) list;

-                assert (p >= list.pool.baseAddr);
-                assert (p < list.pool.topAddr);
+                assert (p >= pool.baseAddr);
+                assert (p < pool.topAddr);
+                assert (pool.freebits.test((p - pool.baseAddr) / 16));
+                free_mem += binsize[i];

             }
         }
             }
         }

+        assert (gc.total_mem == total_mem);
+        assert (gc.free_mem == free_mem);

     }
     return true;
 }
     }
     return true;
 }


@@ -307,8 +340,11 @@ BlkInfo getInfo(void* p)
         return BlkInfo.init;
     BlkInfo info;
     info.base = pool.findBase(p);
         return BlkInfo.init;
     BlkInfo info;
     info.base = pool.findBase(p);

+    if (info.base is null)
+        return BlkInfo.init;

     info.size = pool.findSize(info.base);
     info.size = pool.findSize(info.base);

-    info.attr = getAttr(pool, cast(size_t)(info.base - pool.baseAddr) / 16u);
+    size_t bit_i = (info.base - pool.baseAddr) / 16;
+    info.attr = getAttr(pool, bit_i);

     if (has_pointermap(info.attr)) {
         info.size -= size_t.sizeof; // PointerMap bitmask
         // Points to the PointerMap bitmask pointer, not user data
     if (has_pointermap(info.attr)) {
         info.size -= size_t.sizeof; // PointerMap bitmask
         // Points to the PointerMap bitmask pointer, not user data


@@ -382,7 +418,7 @@ Bins findBin(size_t size)
 size_t reserve(size_t size)
 {
     assert(size != 0);
 size_t reserve(size_t size)
 {
     assert(size != 0);

-    size_t npages = (size + PAGESIZE - 1) / PAGESIZE;
+    size_t npages = round_up(size, PAGESIZE);

     Pool*  pool = newPool(npages);
 
     if (!pool)
     Pool*  pool = newPool(npages);
 
     if (!pool)


@@ -393,16 +429,23 @@ size_t reserve(size_t size)
 
 /**
  * Minimizes physical memory usage by returning free pools to the OS.
 
 /**
  * Minimizes physical memory usage by returning free pools to the OS.

+ *
+ * If full is false, keep some pools alive if the resulting free memory would
+ * be too small.

  */
  */

-void minimize()
+void minimize(bool full = true)

 {
 {

-    size_t n;
-    size_t pn;
-    Pool* pool;
+    // The shared mark bits of the freed pool might be used by the mark process
+    if (collect_in_progress())
+        return;

 
 

-    for (n = 0; n < gc.pools.length; n++)
+    if (gc.pools.length == 0)
+        return;
+
+    for (size_t n = 0; n < gc.pools.length; n++)

     {
     {

-        pool = gc.pools[n];
+        Pool* pool = gc.pools[n];
+        size_t pn;

         for (pn = 0; pn < pool.npages; pn++)
         {
             if (cast(Bins)pool.pagetable[pn] != B_FREE)
         for (pn = 0; pn < pool.npages; pn++)
         {
             if (cast(Bins)pool.pagetable[pn] != B_FREE)


@@ -410,6 +453,16 @@ void minimize()
         }
         if (pn < pool.npages)
             continue;
         }
         if (pn < pool.npages)
             continue;

+        // Free pool
+        size_t pool_size = pool.npages * PAGESIZE;
+        if (!full) {
+            double percent_free = (gc.free_mem - pool_size) * 100.0 /
+                    (gc.total_mem - pool_size);
+            if (percent_free < opts.options.min_free)
+                continue; // not enough free, don't remove this pool
+        }
+        gc.total_mem -= pool_size;
+        gc.free_mem -= pool_size;

         pool.Dtor();
         cstdlib.free(pool);
         gc.pools.remove_at(n);
         pool.Dtor();
         cstdlib.free(pool);
         gc.pools.remove_at(n);


@@ -424,87 +477,50 @@ void minimize()
  * Allocate a chunk of memory that is larger than a page.
  * Return null if out of memory.
  */
  * Allocate a chunk of memory that is larger than a page.
  * Return null if out of memory.
  */

-void* bigAlloc(size_t size, out Pool* pool)
+void* bigAlloc(size_t npages, out Pool* pool, size_t* pn, bool* collected)

 {
 {

-    size_t npages;
-    size_t n;
-    size_t pn;
-    size_t freedpages;
-    void*  p;
-    int    state;
+    *collected = false;
+    // This code could use some refinement when repeatedly
+    // allocating very large arrays.

 
 

-    npages = (size + PAGESIZE - 1) / PAGESIZE;
-
-    for (state = 0; ; )
+    void* find_block()

     {
     {

-        // This code could use some refinement when repeatedly
-        // allocating very large arrays.
-
-        for (n = 0; n < gc.pools.length; n++)
+        for (size_t n = 0; n < gc.pools.length; n++)

         {
             pool = gc.pools[n];
         {
             pool = gc.pools[n];

-            pn = pool.allocPages(npages);
-            if (pn != OPFAIL)
-                goto L1;
+            *pn = pool.allocPages(npages);
+            if (*pn != OPFAIL)
+                return pool.baseAddr + *pn * PAGESIZE;

         }
         }

+        return null;
+    }

 
 

-        // Failed
-        switch (state)
-        {
-        case 0:
-            if (gc.disabled)
-            {
-                state = 1;
-                continue;
-            }
-            // Try collecting
-            freedpages = fullcollectshell();
-            if (freedpages >= gc.pools.length * ((POOLSIZE / PAGESIZE) / 4))
-            {
-                state = 1;
-                continue;
-            }
-            // Release empty pools to prevent bloat
-            minimize();
-            // Allocate new pool
-            pool = newPool(npages);
-            if (!pool)
-            {
-                state = 2;
-                continue;
-            }
-            pn = pool.allocPages(npages);
-            assert(pn != OPFAIL);
-            goto L1;
-        case 1:
-            // Release empty pools to prevent bloat
-            minimize();
-            // Allocate new pool
-            pool = newPool(npages);
-            if (!pool)
-                goto Lnomemory;
-            pn = pool.allocPages(npages);
-            assert(pn != OPFAIL);
-            goto L1;
-        case 2:
-            goto Lnomemory;
-        default:
-            assert(false);
-        }
+    void* alloc_more()
+    {
+        // Allocate new pool
+        pool = newPool(npages);
+        if (!pool)
+            return null; // let malloc handle the error
+        *pn = pool.allocPages(npages);
+        assert(*pn != OPFAIL);
+        return pool.baseAddr + *pn * PAGESIZE;

     }
 
     }
 

-  L1:
-    pool.pagetable[pn] = B_PAGE;
-    if (npages > 1)
-        memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
-    p = pool.baseAddr + pn * PAGESIZE;
-    memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
-    if (opts.options.mem_stomp)
-        memset(p, 0xF1, size);
-    return p;
+    if (void* p = find_block())
+        return p;

 
 

-  Lnomemory:
-    return null; // let mallocNoSync handle the error
+    if (gc.disabled)
+        return alloc_more();
+
+    // Try collecting
+    size_t freedpages = fullcollectshell();
+    *collected = true;
+    if (freedpages >= npages) {
+        if (void* p = find_block())
+            return p;
+    }
+
+    return alloc_more();

 }
 
 
 }
 
 


@@ -555,6 +571,9 @@ Pool *newPool(size_t npages)
     assert (inserted_pool is pool);
     gc.min_addr = gc.pools[0].baseAddr;
     gc.max_addr = gc.pools[gc.pools.length - 1].topAddr;
     assert (inserted_pool is pool);
     gc.min_addr = gc.pools[0].baseAddr;
     gc.max_addr = gc.pools[gc.pools.length - 1].topAddr;

+    size_t pool_size = pool.topAddr - pool.baseAddr;
+    gc.total_mem += pool_size;
+    gc.free_mem += pool_size;

     return pool;
 }
 
     return pool;
 }
 


@@ -567,12 +586,9 @@ Pool *newPool(size_t npages)
 int allocPage(Bins bin)
 {
     Pool*  pool;
 int allocPage(Bins bin)
 {
     Pool*  pool;

-    size_t n;

     size_t pn;
     size_t pn;

-    byte*  p;
-    byte*  ptop;

 
 

-    for (n = 0; n < gc.pools.length; n++)
+    for (size_t n = 0; n < gc.pools.length; n++)

     {
         pool = gc.pools[n];
         pn = pool.allocPages(1);
     {
         pool = gc.pools[n];
         pn = pool.allocPages(1);


@@ -588,8 +604,10 @@ int allocPage(Bins bin)
     size_t size = binsize[bin];
     auto list_head = &gc.free_list[bin];
 
     size_t size = binsize[bin];
     auto list_head = &gc.free_list[bin];
 

-    p = pool.baseAddr + pn * PAGESIZE;
-    ptop = p + PAGESIZE;
+    byte* p = pool.baseAddr + pn * PAGESIZE;
+    byte*  ptop = p + PAGESIZE;
+    size_t bit_i = pn * (PAGESIZE / 16);
+    pool.freebits.set_group(bit_i, PAGESIZE / 16);

     for (; p < ptop; p += size)
     {
         List* l = cast(List *) p;
     for (; p < ptop; p += size)
     {
         List* l = cast(List *) p;


@@ -615,7 +633,7 @@ void mark_range(void *pbot, void *ptop, size_t* pm_bitmask)
     void **p1 = cast(void **)pbot;
     void **p2 = cast(void **)ptop;
     size_t pcache = 0;
     void **p1 = cast(void **)pbot;
     void **p2 = cast(void **)ptop;
     size_t pcache = 0;

-    uint changes = 0;
+    bool changes = false;

 
     size_t type_size = pm_bitmask[0];
     size_t* pm_bits = pm_bitmask + 1;
 
     size_t type_size = pm_bitmask[0];
     size_t* pm_bits = pm_bitmask + 1;


@@ -641,7 +659,7 @@ void mark_range(void *pbot, void *ptop, size_t* pm_bitmask)
             if (pool)
             {
                 size_t offset = cast(size_t)(p - pool.baseAddr);
             if (pool)
             {
                 size_t offset = cast(size_t)(p - pool.baseAddr);

-                size_t bit_i;
+                size_t bit_i = void;

                 size_t pn = offset / PAGESIZE;
                 Bins   bin = cast(Bins)pool.pagetable[pn];
 
                 size_t pn = offset / PAGESIZE;
                 Bins   bin = cast(Bins)pool.pagetable[pn];
 


@@ -651,7 +669,7 @@ void mark_range(void *pbot, void *ptop, size_t* pm_bitmask)
 
                 // Adjust bit to be at start of allocated memory block
                 if (bin <= B_PAGE)
 
                 // Adjust bit to be at start of allocated memory block
                 if (bin <= B_PAGE)

-                    bit_i = (offset & notbinsize[bin]) >> 4;
+                    bit_i = (offset & notbinsize[bin]) / 16;

                 else if (bin == B_PAGEPLUS)
                 {
                     do
                 else if (bin == B_PAGEPLUS)
                 {
                     do


@@ -670,7 +688,7 @@ void mark_range(void *pbot, void *ptop, size_t* pm_bitmask)
                     if (!pool.noscan.test(bit_i))
                     {
                         pool.scan.set(bit_i);
                     if (!pool.noscan.test(bit_i))
                     {
                         pool.scan.set(bit_i);

-                        changes = 1;
+                        changes = true;

                     }
                 }
             }
                     }
                 }
             }


@@ -778,17 +796,56 @@ size_t fullcollect(void *stackTop)
 {
     debug(COLLECT_PRINTF) printf("Gcx.fullcollect()\n");
 
 {
     debug(COLLECT_PRINTF) printf("Gcx.fullcollect()\n");
 

-    // we always need to stop the world to make threads save the CPU registers
+    // If eager allocation is used, we need to check first if there is a mark
+    // process running. If there isn't, we start a new one (see the next code
+    // block). If there is, we check if it's still running or already finished.
+    // If it's still running, we tell the caller process no memory has been
+    // recovered (it will allocated more to fulfill the current request).  If
+    // the mark process is done, we lunch the sweep phase and hope enough
+    // memory is freed (if that not the case, the caller will allocate more
+    // memory and the next time it's exhausted it will run a new collection).
+    if (opts.options.eager_alloc) {
+        if (collect_in_progress()) {
+            os.WRes r = os.wait_pid(gc.mark_proc_pid, false); // don't block
+            assert (r != os.WRes.ERROR);
+            switch (r) {
+            case os.WRes.DONE:
+                debug(COLLECT_PRINTF) printf("\t\tmark proc DONE\n");
+                gc.mark_proc_pid = 0;
+                return sweep();
+            case os.WRes.RUNNING:
+                debug(COLLECT_PRINTF) printf("\t\tmark proc RUNNING\n");
+                return 0;
+            case os.WRes.ERROR:
+                debug(COLLECT_PRINTF) printf("\t\tmark proc ERROR\n");
+                disable_fork(); // Try to keep going without forking
+                break;
+            }
+        }
+    }
+
+    // We always need to stop the world to make threads save the CPU registers

     // in the stack and prepare themselves for thread_scanAll()
     thread_suspendAll();
     gc.stats.world_stopped();
 
     // in the stack and prepare themselves for thread_scanAll()
     thread_suspendAll();
     gc.stats.world_stopped();
 

+    // If forking is enabled, we fork() and start a new mark phase in the
+    // child. The parent process will tell the caller that no memory could be
+    // recycled if eager allocation is used, allowing the mutator to keep going
+    // almost instantly (at the expense of more memory consumption because
+    // a new allocation will be triggered to fulfill the current request). If
+    // no eager allocation is used, the parent will wait for the mark phase to
+    // finish before returning control to the mutator, but other threads are
+    // restarted and may run in parallel with the mark phase (unless they
+    // allocate or use the GC themselves, in which case the global GC lock will
+    // stop them).

     if (opts.options.fork) {
     if (opts.options.fork) {

+        cstdio.fflush(null); // avoid duplicated FILE* output

         os.pid_t child_pid = os.fork();
         assert (child_pid != -1); // don't accept errors in non-release mode
         switch (child_pid) {
         os.pid_t child_pid = os.fork();
         assert (child_pid != -1); // don't accept errors in non-release mode
         switch (child_pid) {

-        case -1: // if fork() fails, fallback to stop-the-world
-            opts.options.fork = false;
+        case -1: // if fork() fails, fall-back to stop-the-world
+            disable_fork();

             break;
         case 0: // child process (i.e. the collectors mark phase)
             mark(stackTop);
             break;
         case 0: // child process (i.e. the collectors mark phase)
             mark(stackTop);


@@ -798,15 +855,28 @@ size_t fullcollect(void *stackTop)
             // start the world again and wait for the mark phase to finish
             thread_resumeAll();
             gc.stats.world_started();
             // start the world again and wait for the mark phase to finish
             thread_resumeAll();
             gc.stats.world_started();

-            int status = void;
-            os.pid_t wait_pid = os.waitpid(child_pid, &status, 0);
-            assert (wait_pid == child_pid);
-            return sweep();
+            if (opts.options.eager_alloc) {
+                gc.mark_proc_pid = child_pid;
+                return 0;
+            }
+            os.WRes r = os.wait_pid(child_pid); // block until it finishes
+            assert (r == os.WRes.DONE);
+            debug(COLLECT_PRINTF) printf("\t\tmark proc DONE (block)\n");
+            if (r == os.WRes.DONE)
+                return sweep();
+            debug(COLLECT_PRINTF) printf("\tmark() proc ERROR\n");
+            // If there was some error, try to keep going without forking
+            disable_fork();
+            // Re-suspend the threads to do the marking in this process
+            thread_suspendAll();
+            gc.stats.world_stopped();

         }
 
     }
 
         }
 
     }
 

-    // if we reach here, we are using the standard stop-the-world collection
+    // If we reach here, we are using the standard stop-the-world collection,
+    // either because fork was disabled in the first place, or because it was
+    // disabled because of some error.

     mark(stackTop);
     thread_resumeAll();
     gc.stats.world_started();
     mark(stackTop);
     thread_resumeAll();
     gc.stats.world_started();


@@ -822,37 +892,13 @@ void mark(void *stackTop)
 {
     debug(COLLECT_PRINTF) printf("\tmark()\n");
 
 {
     debug(COLLECT_PRINTF) printf("\tmark()\n");
 

-    gc.p_cache = null;
-    gc.size_cache = 0;
-

     gc.any_changes = false;
     gc.any_changes = false;

-    for (size_t n = 0; n < gc.pools.length; n++)
-    {
-        Pool* pool = gc.pools[n];
-        pool.mark.zero();
-        pool.scan.zero();
-        pool.freebits.zero();
-    }
-
-    // Mark each free entry, so it doesn't get scanned
-    for (size_t n = 0; n < B_PAGE; n++)
-    {
-        for (List *list = gc.free_list[n]; list; list = list.next)
-        {
-            Pool* pool = list.pool;
-            auto ptr = cast(byte*) list;
-            assert (pool);
-            assert (pool.baseAddr <= ptr);
-            assert (ptr < pool.topAddr);
-            size_t bit_i = cast(size_t)(ptr - pool.baseAddr) / 16;
-            pool.freebits.set(bit_i);
-        }
-    }

 
     for (size_t n = 0; n < gc.pools.length; n++)
     {
         Pool* pool = gc.pools[n];
         pool.mark.copy(&pool.freebits);
 
     for (size_t n = 0; n < gc.pools.length; n++)
     {
         Pool* pool = gc.pools[n];
         pool.mark.copy(&pool.freebits);

+        pool.scan.zero();

     }
 
     /// Marks a range of memory in conservative mode.
     }
 
     /// Marks a range of memory in conservative mode.


@@ -970,6 +1016,9 @@ size_t sweep()
 {
     // Free up everything not marked
     debug(COLLECT_PRINTF) printf("\tsweep\n");
 {
     // Free up everything not marked
     debug(COLLECT_PRINTF) printf("\tsweep\n");

+    gc.p_cache = null;
+    gc.size_cache = 0;
+    gc.free_mem = 0; // will be recalculated

     size_t freedpages = 0;
     size_t freed = 0;
     for (size_t n = 0; n < gc.pools.length; n++)
     size_t freedpages = 0;
     size_t freed = 0;
     for (size_t n = 0; n < gc.pools.length; n++)


@@ -999,7 +1048,7 @@ version(none) // BUG: doesn't work because freebits() must also be cleared
                 {
                     for (; p < ptop; p += size, bit_i += bit_stride)
                     {
                 {
                     for (; p < ptop; p += size, bit_i += bit_stride)
                     {

-                        if (pool.finals.nbits && pool.finals.testClear(bit_i)) {
+                        if (pool.finals.testClear(bit_i)) {

                             if (opts.options.sentinel)
                                 rt_finalize(sentinel_add(p), false/*gc.no_stack > 0*/);
                             else
                             if (opts.options.sentinel)
                                 rt_finalize(sentinel_add(p), false/*gc.no_stack > 0*/);
                             else


@@ -1023,7 +1072,7 @@ version(none) // BUG: doesn't work because freebits() must also be cleared
                             sentinel_Invariant(sentinel_add(p));
 
                         pool.freebits.set(bit_i);
                             sentinel_Invariant(sentinel_add(p));
 
                         pool.freebits.set(bit_i);

-                        if (pool.finals.nbits && pool.finals.testClear(bit_i)) {
+                        if (pool.finals.testClear(bit_i)) {

                             if (opts.options.sentinel)
                                 rt_finalize(sentinel_add(p), false/*gc.no_stack > 0*/);
                             else
                             if (opts.options.sentinel)
                                 rt_finalize(sentinel_add(p), false/*gc.no_stack > 0*/);
                             else


@@ -1040,13 +1089,14 @@ version(none) // BUG: doesn't work because freebits() must also be cleared
             }
             else if (bin == B_PAGE)
             {
             }
             else if (bin == B_PAGE)
             {

-                size_t bit_i = pn * (PAGESIZE / 16);
+                size_t bit_stride = PAGESIZE / 16;
+                size_t bit_i = pn * bit_stride;

                 if (!pool.mark.test(bit_i))
                 {
                     byte *p = pool.baseAddr + pn * PAGESIZE;
                     if (opts.options.sentinel)
                         sentinel_Invariant(sentinel_add(p));
                 if (!pool.mark.test(bit_i))
                 {
                     byte *p = pool.baseAddr + pn * PAGESIZE;
                     if (opts.options.sentinel)
                         sentinel_Invariant(sentinel_add(p));

-                    if (pool.finals.nbits && pool.finals.testClear(bit_i)) {
+                    if (pool.finals.testClear(bit_i)) {

                         if (opts.options.sentinel)
                             rt_finalize(sentinel_add(p), false/*gc.no_stack > 0*/);
                         else
                         if (opts.options.sentinel)
                             rt_finalize(sentinel_add(p), false/*gc.no_stack > 0*/);
                         else


@@ -1054,16 +1104,21 @@ version(none) // BUG: doesn't work because freebits() must also be cleared
                     }
                     clrAttr(pool, bit_i, BlkAttr.ALL_BITS);
 
                     }
                     clrAttr(pool, bit_i, BlkAttr.ALL_BITS);
 

-                    debug(COLLECT_PRINTF) printf("\tcollecting big %x\n", p);
+                    debug(COLLECT_PRINTF) printf("\tcollecting big %p\n", p);

                     pool.pagetable[pn] = B_FREE;
                     pool.pagetable[pn] = B_FREE;

+                    pool.freebits.set_group(bit_i, PAGESIZE / 16);

                     freedpages++;
                     freedpages++;

+                    gc.free_mem += PAGESIZE;

                     if (opts.options.mem_stomp)
                         memset(p, 0xF3, PAGESIZE);
                     while (pn + 1 < pool.npages && pool.pagetable[pn + 1] == B_PAGEPLUS)
                     {
                         pn++;
                         pool.pagetable[pn] = B_FREE;
                     if (opts.options.mem_stomp)
                         memset(p, 0xF3, PAGESIZE);
                     while (pn + 1 < pool.npages && pool.pagetable[pn + 1] == B_PAGEPLUS)
                     {
                         pn++;
                         pool.pagetable[pn] = B_FREE;

+                        bit_i += bit_stride;
+                        pool.freebits.set_group(bit_i, PAGESIZE / 16);

                         freedpages++;
                         freedpages++;

+                        gc.free_mem += PAGESIZE;

 
                         if (opts.options.mem_stomp)
                         {
 
                         if (opts.options.mem_stomp)
                         {


@@ -1073,6 +1128,9 @@ version(none) // BUG: doesn't work because freebits() must also be cleared
                     }
                 }
             }
                     }
                 }
             }

+            else if (bin == B_FREE) {
+                gc.free_mem += PAGESIZE;
+            }

         }
     }
 
         }
     }
 


@@ -1106,7 +1164,9 @@ version(none) // BUG: doesn't work because freebits() must also be cleared
                         goto Lnotfree;
                 }
                 pool.pagetable[pn] = B_FREE;
                         goto Lnotfree;
                 }
                 pool.pagetable[pn] = B_FREE;

+                pool.freebits.set_group(bit_base, PAGESIZE / 16);

                 recoveredpages++;
                 recoveredpages++;

+                gc.free_mem += PAGESIZE;

                 continue;
 
              Lnotfree:
                 continue;
 
              Lnotfree:


@@ -1125,6 +1185,7 @@ version(none) // BUG: doesn't work because freebits() must also be cleared
                         if (list.pool != pool)
                             list.pool = pool;
                         gc.free_list[bin] = list;
                         if (list.pool != pool)
                             list.pool = pool;
                         gc.free_list[bin] = list;

+                        gc.free_mem += binsize[bin];

                     }
                 }
             }
                     }
                 }
             }


@@ -1149,14 +1210,11 @@ in
 body
 {
     uint attrs;
 body
 {
     uint attrs;

-
-    if (pool.finals.nbits &&
-        pool.finals.test(bit_i))
+    if (pool.finals.test(bit_i))

         attrs |= BlkAttr.FINALIZE;
     if (pool.noscan.test(bit_i))
         attrs |= BlkAttr.NO_SCAN;
         attrs |= BlkAttr.FINALIZE;
     if (pool.noscan.test(bit_i))
         attrs |= BlkAttr.NO_SCAN;

-//        if (pool.nomove.nbits &&
-//            pool.nomove.test(bit_i))
+//        if (pool.nomove.test(bit_i))

 //            attrs |= BlkAttr.NO_MOVE;
     return attrs;
 }
 //            attrs |= BlkAttr.NO_MOVE;
     return attrs;
 }


@@ -1174,8 +1232,6 @@ body
 {
     if (mask & BlkAttr.FINALIZE)
     {
 {
     if (mask & BlkAttr.FINALIZE)
     {

-        if (!pool.finals.nbits)
-            pool.finals.alloc(pool.mark.nbits);

         pool.finals.set(bit_i);
     }
     if (mask & BlkAttr.NO_SCAN)
         pool.finals.set(bit_i);
     }
     if (mask & BlkAttr.NO_SCAN)


@@ -1201,7 +1257,7 @@ in
 }
 body
 {
 }
 body
 {

-    if (mask & BlkAttr.FINALIZE && pool.finals.nbits)
+    if (mask & BlkAttr.FINALIZE)

         pool.finals.clear(bit_i);
     if (mask & BlkAttr.NO_SCAN)
         pool.noscan.clear(bit_i);
         pool.finals.clear(bit_i);
     if (mask & BlkAttr.NO_SCAN)
         pool.noscan.clear(bit_i);


@@ -1210,6 +1266,13 @@ body
 }
 
 
 }
 
 

+void disable_fork()
+{
+    // we have to disable both options, as eager_alloc assumes fork is enabled
+    opts.options.fork = false;
+    opts.options.eager_alloc = false;
+}
+

 
 void initialize()
 {
 
 void initialize()
 {


@@ -1219,10 +1282,18 @@ void initialize()
     // If we are going to fork, make sure we have the needed OS support
     if (opts.options.fork)
         opts.options.fork = os.HAVE_SHARED && os.HAVE_FORK;
     // If we are going to fork, make sure we have the needed OS support
     if (opts.options.fork)
         opts.options.fork = os.HAVE_SHARED && os.HAVE_FORK;

+    // Eager allocation is only possible when forking
+    if (!opts.options.fork)
+        opts.options.eager_alloc = false;

     gc.lock = GCLock.classinfo;
     gc.inited = 1;
     setStackBottom(rt_stackBottom());
     gc.stats = Stats(gc);
     gc.lock = GCLock.classinfo;
     gc.inited = 1;
     setStackBottom(rt_stackBottom());
     gc.stats = Stats(gc);

+    if (opts.options.prealloc_npools) {
+        size_t pages = round_up(opts.options.prealloc_psize, PAGESIZE);
+        for (size_t i = 0; i < opts.options.prealloc_npools; ++i)
+            newPool(pages);
+    }

 }
 
 
 }
 
 


@@ -1261,7 +1332,9 @@ private void *malloc(size_t size, uint attrs, size_t* pm_bitmask)
     }
 
     Pool* pool = void;
     }
 
     Pool* pool = void;

+    size_t bit_i = void;

     size_t capacity = void; // to figure out where to store the bitmask
     size_t capacity = void; // to figure out where to store the bitmask

+    bool collected = false;

     if (bin < B_PAGE)
     {
         p = gc.free_list[bin];
     if (bin < B_PAGE)
     {
         p = gc.free_list[bin];


@@ -1284,6 +1357,7 @@ private void *malloc(size_t size, uint attrs, size_t* pm_bitmask)
                 {
                     //newPool(1);
                 }
                 {
                     //newPool(1);
                 }

+                collected = true;

             }
             if (!gc.free_list[bin] && !allocPage(bin))
             {
             }
             if (!gc.free_list[bin] && !allocPage(bin))
             {


@@ -1303,6 +1377,9 @@ private void *malloc(size_t size, uint attrs, size_t* pm_bitmask)
         assert ((cast(byte*)list) < list.pool.topAddr);
         gc.free_list[bin] = list.next;
         pool = list.pool;
         assert ((cast(byte*)list) < list.pool.topAddr);
         gc.free_list[bin] = list.next;
         pool = list.pool;

+        bit_i = (p - pool.baseAddr) / 16;
+        assert (pool.freebits.test(bit_i));
+        pool.freebits.clear(bit_i);

         if (!(attrs & BlkAttr.NO_SCAN))
             memset(p + size, 0, capacity - size);
         if (opts.options.mem_stomp)
         if (!(attrs & BlkAttr.NO_SCAN))
             memset(p + size, 0, capacity - size);
         if (opts.options.mem_stomp)


@@ -1310,13 +1387,24 @@ private void *malloc(size_t size, uint attrs, size_t* pm_bitmask)
     }
     else
     {
     }
     else
     {

-        p = bigAlloc(size, pool);
+        size_t pn;
+        size_t npages = round_up(size, PAGESIZE);
+        p = bigAlloc(npages, pool, &pn, &collected);

         if (!p)
             onOutOfMemoryError();
         assert (pool !is null);
         if (!p)
             onOutOfMemoryError();
         assert (pool !is null);

-        // Round the size up to the number of pages needed to store it
-        size_t npages = (size + PAGESIZE - 1) / PAGESIZE;
+

         capacity = npages * PAGESIZE;
         capacity = npages * PAGESIZE;

+        bit_i = pn * (PAGESIZE / 16);
+        pool.freebits.clear(bit_i);
+        pool.pagetable[pn] = B_PAGE;
+        if (npages > 1)
+            memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
+        p = pool.baseAddr + pn * PAGESIZE;
+        memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
+        if (opts.options.mem_stomp)
+            memset(p, 0xF1, size);
+

     }
 
     // Store the bit mask AFTER SENTINEL_POST
     }
 
     // Store the bit mask AFTER SENTINEL_POST


@@ -1333,8 +1421,25 @@ private void *malloc(size_t size, uint attrs, size_t* pm_bitmask)
         sentinel_init(p, size);
     }
 
         sentinel_init(p, size);
     }
 

-    if (attrs)
-        setAttr(pool, cast(size_t)(p - pool.baseAddr) / 16, attrs);
+    if (attrs) {
+        setAttr(pool, bit_i, attrs);
+        assert (bin >= B_PAGE || !pool.freebits.test(bit_i));
+    }
+
+    gc.free_mem -= capacity;
+    if (collected) {
+        // If there is not enough free memory, allocate a new pool big enough
+        // to have at least the min_free% of the total heap free. If there is
+        // too much free memory, try to free some empty pools.
+        double percent_free = gc.free_mem * 100.0 / gc.total_mem;
+        if (percent_free < opts.options.min_free) {
+            auto pool_size = gc.total_mem * 1.0 / opts.options.min_free
+                    - gc.free_mem;
+            newPool(round_up(cast(size_t)pool_size, PAGESIZE));
+        }
+        else
+            minimize(false);
+    }

 
     return p;
 }
 
     return p;
 }


@@ -1359,132 +1464,125 @@ private void *calloc(size_t size, uint attrs, size_t* pm_bitmask)
 private void *realloc(void *p, size_t size, uint attrs,
         size_t* pm_bitmask)
 {
 private void *realloc(void *p, size_t size, uint attrs,
         size_t* pm_bitmask)
 {

-    if (!size)
-    {
+    if (!size) {

         if (p)
         if (p)

-        {

             free(p);
             free(p);

-            p = null;
-        }
+        return null;

     }
     }

-    else if (!p)
-    {
-        p = malloc(size, attrs, pm_bitmask);
+
+    if (p is null)
+        return malloc(size, attrs, pm_bitmask);
+
+    Pool* pool = findPool(p);
+    if (pool is null)
+        return null;
+
+    // Set or retrieve attributes as appropriate
+    auto bit_i = cast(size_t)(p - pool.baseAddr) / 16;
+    if (attrs) {
+        clrAttr(pool, bit_i, BlkAttr.ALL_BITS);
+        setAttr(pool, bit_i, attrs);

     }
     else
     }
     else

-    {
-        Pool* pool = findPool(p);
-        if (pool is null)
-            return null;
+        attrs = getAttr(pool, bit_i);

 
 

-        // Set or retrieve attributes as appropriate
-        auto bit_i = cast(size_t)(p - pool.baseAddr) / 16;
-        if (attrs) {
-            clrAttr(pool, bit_i, BlkAttr.ALL_BITS);
-            setAttr(pool, bit_i, attrs);
-        }
-        else
-            attrs = getAttr(pool, bit_i);
-
-        void* blk_base_addr = pool.findBase(p);
-        size_t blk_size = pool.findSize(p);
-        bool has_pm = has_pointermap(attrs);
-        size_t pm_bitmask_size = 0;
-        if (has_pm) {
-            pm_bitmask_size = size_t.sizeof;
-            // Retrieve pointer map bit mask if appropriate
-            if (pm_bitmask is null) {
-                auto end_of_blk = cast(size_t**)(blk_base_addr +
-                        blk_size - size_t.sizeof);
-                pm_bitmask = *end_of_blk;
-            }
+    void* blk_base_addr = pool.findBase(p);
+    size_t blk_size = pool.findSize(p);
+    bool has_pm = has_pointermap(attrs);
+    size_t pm_bitmask_size = 0;
+    if (has_pm) {
+        pm_bitmask_size = size_t.sizeof;
+        // Retrieve pointer map bit mask if appropriate
+        if (pm_bitmask is null) {
+            auto end_of_blk = cast(size_t**)(
+                    blk_base_addr + blk_size - size_t.sizeof);
+            pm_bitmask = *end_of_blk;

         }
         }

+    }

 
 

-        if (opts.options.sentinel)
-        {
-            sentinel_Invariant(p);
-            size_t sentinel_stored_size = *sentinel_size(p);
-            if (sentinel_stored_size != size)
-            {
-                void* p2 = malloc(size, attrs, pm_bitmask);
-                if (sentinel_stored_size < size)
-                    size = sentinel_stored_size;
-                cstring.memcpy(p2, p, size);
-                p = p2;
+    if (opts.options.sentinel) {
+        sentinel_Invariant(p);
+        size_t sentinel_stored_size = *sentinel_size(p);
+        if (sentinel_stored_size != size) {
+            void* p2 = malloc(size, attrs, pm_bitmask);
+            if (sentinel_stored_size < size)
+                size = sentinel_stored_size;
+            cstring.memcpy(p2, p, size);
+            p = p2;
+        }
+        return p;
+    }
+
+    size += pm_bitmask_size;
+    if (blk_size >= PAGESIZE && size >= PAGESIZE) {
+        auto psz = blk_size / PAGESIZE;
+        auto newsz = round_up(size, PAGESIZE);
+        if (newsz == psz)
+            return p;
+
+        auto pagenum = (p - pool.baseAddr) / PAGESIZE;
+
+        if (newsz < psz) {
+            // Shrink in place
+            if (opts.options.mem_stomp)
+                memset(p + size - pm_bitmask_size, 0xF2,
+                        blk_size - size - pm_bitmask_size);
+            pool.freePages(pagenum + newsz, psz - newsz);
+            auto new_blk_size = (PAGESIZE * newsz);
+            gc.free_mem += blk_size - new_blk_size;
+            // update the size cache, assuming that is very likely the
+            // size of this block will be queried in the near future
+            pool.update_cache(p, new_blk_size);
+            if (has_pm) {
+                auto end_of_blk = cast(size_t**)(blk_base_addr +
+                        new_blk_size - pm_bitmask_size);
+                *end_of_blk = pm_bitmask;

             }
             }

+            return p;

         }
         }

-        else
-        {
-            size += pm_bitmask_size;
-            if (blk_size >= PAGESIZE && size >= PAGESIZE)
-            {
-                auto psz = blk_size / PAGESIZE;
-                auto newsz = (size + PAGESIZE - 1) / PAGESIZE;
-                if (newsz == psz)
-                    return p;

 
 

-                auto pagenum = (p - pool.baseAddr) / PAGESIZE;
-
-                if (newsz < psz)
-                {
-                    // Shrink in place
+        if (pagenum + newsz <= pool.npages) {
+            // Attempt to expand in place
+            for (size_t i = pagenum + psz; 1;) {
+                if (i == pagenum + newsz) {

                     if (opts.options.mem_stomp)
                     if (opts.options.mem_stomp)

-                        memset(p + size - pm_bitmask_size, 0xF2,
-                                blk_size - size - pm_bitmask_size);
-                    pool.freePages(pagenum + newsz, psz - newsz);
+                        memset(p + blk_size - pm_bitmask_size, 0xF0,
+                                size - blk_size - pm_bitmask_size);
+                    memset(pool.pagetable + pagenum + psz, B_PAGEPLUS,
+                            newsz - psz);
+                    auto new_blk_size = (PAGESIZE * newsz);
+                    gc.free_mem -= new_blk_size - blk_size;
+                    // update the size cache, assuming that is very
+                    // likely the size of this block will be queried in
+                    // the near future
+                    pool.update_cache(p, new_blk_size);

                     if (has_pm) {
                         auto end_of_blk = cast(size_t**)(
                     if (has_pm) {
                         auto end_of_blk = cast(size_t**)(

-                                blk_base_addr + (PAGESIZE * newsz) -
-                                pm_bitmask_size);
+                                blk_base_addr + new_blk_size - pm_bitmask_size);

                         *end_of_blk = pm_bitmask;
                     }
                     return p;
                 }
                         *end_of_blk = pm_bitmask;
                     }
                     return p;
                 }

-                else if (pagenum + newsz <= pool.npages)
-                {
-                    // Attempt to expand in place
-                    for (size_t i = pagenum + psz; 1;)
-                    {
-                        if (i == pagenum + newsz)
-                        {
-                            if (opts.options.mem_stomp)
-                                memset(p + blk_size - pm_bitmask_size,
-                                        0xF0, size - blk_size
-                                        - pm_bitmask_size);
-                            memset(pool.pagetable + pagenum +
-                                    psz, B_PAGEPLUS, newsz - psz);
-                            if (has_pm) {
-                                auto end_of_blk = cast(size_t**)(
-                                        blk_base_addr +
-                                        (PAGESIZE * newsz) -
-                                        pm_bitmask_size);
-                                *end_of_blk = pm_bitmask;
-                            }
-                            return p;
-                        }
-                        if (i == pool.npages)
-                        {
-                            break;
-                        }
-                        if (pool.pagetable[i] != B_FREE)
-                            break;
-                        i++;
-                    }
-                }
-            }
-            // if new size is bigger or less than half
-            if (blk_size < size || blk_size > size * 2)
-            {
-                size -= pm_bitmask_size;
-                blk_size -= pm_bitmask_size;
-                void* p2 = malloc(size, attrs, pm_bitmask);
-                if (blk_size < size)
-                    size = blk_size;
-                cstring.memcpy(p2, p, size);
-                p = p2;
+                if (i == pool.npages)
+                    break;
+                if (pool.pagetable[i] != B_FREE)
+                    break;
+                i++;

             }
         }
     }
             }
         }
     }

+
+    // if new size is bigger or less than half
+    if (blk_size < size || blk_size > size * 2) {
+        size -= pm_bitmask_size;
+        blk_size -= pm_bitmask_size;
+        void* p2 = malloc(size, attrs, pm_bitmask);
+        if (blk_size < size)
+            size = blk_size;
+        cstring.memcpy(p2, p, size);
+        p = p2;
+    }
+

     return p;
 }
 
     return p;
 }
 


@@ -1536,8 +1634,8 @@ body
         return 0; // cannot extend buckets
 
     auto psz = blk_size / PAGESIZE;
         return 0; // cannot extend buckets
 
     auto psz = blk_size / PAGESIZE;

-    auto minsz = (minsize + PAGESIZE - 1) / PAGESIZE;
-    auto maxsz = (maxsize + PAGESIZE - 1) / PAGESIZE;
+    auto minsz = round_up(minsize, PAGESIZE);
+    auto maxsz = round_up(maxsize, PAGESIZE);

 
     auto pagenum = (p - pool.baseAddr) / PAGESIZE;
 
 
     auto pagenum = (p - pool.baseAddr) / PAGESIZE;
 


@@ -1565,6 +1663,10 @@ body
     memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);
     gc.p_cache = null;
     gc.size_cache = 0;
     memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);
     gc.p_cache = null;
     gc.size_cache = 0;

+    gc.free_mem -= new_size - blk_size;
+    // update the size cache, assuming that is very likely the size of this
+    // block will be queried in the near future
+    pool.update_cache(p, new_size);

 
     if (has_pm) {
         new_size -= size_t.sizeof;
 
     if (has_pm) {
         new_size -= size_t.sizeof;


@@ -1605,11 +1707,16 @@ private void free(void *p)
         // Free pages
         size_t npages = 1;
         size_t n = pagenum;
         // Free pages
         size_t npages = 1;
         size_t n = pagenum;

+        pool.freebits.set_group(bit_i, PAGESIZE / 16);

         while (++n < pool.npages && pool.pagetable[n] == B_PAGEPLUS)
             npages++;
         while (++n < pool.npages && pool.pagetable[n] == B_PAGEPLUS)
             npages++;

+        size_t size = npages * PAGESIZE;

         if (opts.options.mem_stomp)
         if (opts.options.mem_stomp)

-            memset(p, 0xF2, npages * PAGESIZE);
+            memset(p, 0xF2, size);

         pool.freePages(pagenum, npages);
         pool.freePages(pagenum, npages);

+        gc.free_mem += size;
+        // just in case we were caching this pointer
+        pool.clear_cache(p);

     }
     else
     {
     }
     else
     {


@@ -1622,7 +1729,12 @@ private void free(void *p)
         list.next = gc.free_list[bin];
         list.pool = pool;
         gc.free_list[bin] = list;
         list.next = gc.free_list[bin];
         list.pool = pool;
         gc.free_list[bin] = list;

+        pool.freebits.set(bit_i);
+        gc.free_mem += binsize[bin];

     }
     }

+    double percent_free = gc.free_mem * 100.0 / gc.total_mem;
+    if (percent_free > opts.options.min_free)
+        minimize(false);

 }
 
 
 }
 
 


@@ -1888,10 +2000,18 @@ struct Pool
     size_t cached_size;
     void* cached_ptr;
 
     size_t cached_size;
     void* cached_ptr;
 

-    void clear_cache()
+    void clear_cache(void* ptr = null)

     {
     {

-        this.cached_ptr = null;
-        this.cached_size = 0;
+        if (ptr is null || ptr is this.cached_ptr) {
+            this.cached_ptr = null;
+            this.cached_size = 0;
+        }
+    }
+
+    void update_cache(void* ptr, size_t size)
+    {
+        this.cached_ptr = ptr;
+        this.cached_size = size;

     }
 
     void initialize(size_t npages)
     }
 
     void initialize(size_t npages)


@@ -1918,10 +2038,17 @@ struct Pool
         if (opts.options.fork)
             vis = os.Vis.SHARED;
         mark.alloc(nbits, vis); // shared between mark and sweep
         if (opts.options.fork)
             vis = os.Vis.SHARED;
         mark.alloc(nbits, vis); // shared between mark and sweep

-        freebits.alloc(nbits, vis); // ditto
+        freebits.alloc(nbits); // not used by the mark phase

         scan.alloc(nbits); // only used in the mark phase
         scan.alloc(nbits); // only used in the mark phase

-        finals.alloc(nbits); // mark phase *MUST* have a snapshot
-        noscan.alloc(nbits); // ditto
+        finals.alloc(nbits); // not used by the mark phase
+        noscan.alloc(nbits); // mark phase *MUST* have a snapshot
+
+        // all is free when we start
+        freebits.set_all();
+
+        // avoid accidental sweeping of new pools while using eager allocation
+        if (collect_in_progress())
+            mark.set_all();

 
         pagetable = cast(ubyte*) cstdlib.malloc(npages);
         if (!pagetable)
 
         pagetable = cast(ubyte*) cstdlib.malloc(npages);
         if (!pagetable)


@@ -1956,7 +2083,7 @@ struct Pool
         if (opts.options.fork)
             vis = os.Vis.SHARED;
         mark.Dtor(vis);
         if (opts.options.fork)
             vis = os.Vis.SHARED;
         mark.Dtor(vis);

-        freebits.Dtor(vis);
+        freebits.Dtor();

         scan.Dtor();
         finals.Dtor();
         noscan.Dtor();
         scan.Dtor();
         finals.Dtor();
         noscan.Dtor();