impl/conservative/gc.d

97 // Track total time spent preparing for GC,
141 alias GC gc_t;
244 /* ============================ GC =============================== */
246 class ConservativeGC : GC
258     // lock GC, throw InvalidMemoryOperationError on recursive locking during finalization
267     static void initialize(ref GC gc)
288     static void finalize(ref GC gc)
320             //debug(PRINTF) printf("GC.Dtor()\n");
507         //debug(PRINTF) printf("GC::malloc(size = %d, gcx = %p)\n", size, gcx);
606             //debug(PRINTF) printf("GC::realloc(p = %p, size = %zu)\n", p, size);
743         //debug(PRINTF) printf("GC::extend(p = %p, minsize = %zu, maxsize = %zu)\n", p, minsize, maxsize);
1139         debug(PRINTF) printf("GC.fullCollect()\n");
1188     core.memory.GC.Stats stats() nothrow
1201     private void getStatsNoSync(out core.memory.GC.Stats stats) nothrow
1321             printf("\tTotal GC prep time:  %lld milliseconds\n",
1332             printf("\tGrand total GC time:  %lld milliseconds\n", gcTime);
1357             printf("GC summary:%5lld MB,%5lld GC%5lld ms, Pauses%5lld ms <%5lld ms%s\n",
1947      * Search a range of memory values and mark any pointers into the GC pool.
2496             log.line = GC.line;
2497             log.file = GC.file;
2500             GC.line = 0;
2501             GC.file = null;
2643             //debug(PRINTF) printf("GC fail: poolsize = x%zx, errno = %d\n", poolsize, errno);
3214     import core.memory : GC;
3220             GC.free(buf); // ignored in finalizer
3225     new Foo(GC.malloc(10));
3226     GC.collect();
3231     import core.memory : GC;
3238             GC.removeRange(ptr);
3239             GC.removeRoot(ptr);
3244     GC.addRoot(buf.ptr);
3245     GC.addRange(buf.ptr, buf.length);
3247     GC.collect();
3340     auto p = cast(uint*)GC.malloc(uint.sizeof*3);
3343     GC.free(p);
3351     auto p = cast(ubyte*)GC.malloc(1);
3358         GC.free(p);
3371     GC.removeRoot(null);
3372     GC.removeRoot(cast(void*)13);
3379     auto p = GC.malloc(260 << 20); // new pool has 390 MB
3380     auto q = GC.malloc(65 << 20);  // next chunk (larger than 64MB to ensure the same pool is used)
3381     auto r = GC.malloc(65 << 20);  // another chunk in same pool
3384     GC.free(q);
3386     GC.collect();
3388     size_t sz = GC.extend(p, 64 << 20, 66 << 20); // trigger size after p large enough (but limited)
3390     GC.free(p);
3391     GC.free(r);
3394     p = GC.malloc(70 << 20); // from the same pool
3395     q = GC.malloc(70 << 20);
3396     r = GC.malloc(70 << 20);
3397     auto s = GC.malloc(70 << 20);
3398     auto t = GC.malloc(70 << 20); // 350 MB of 390 MB used
3403     GC.free(r); // ensure recalculation of largestFree in nxxt allocPages
3404     auto z = GC.malloc(75 << 20); // needs new pool
3406     GC.free(p);
3407     GC.free(q);
3408     GC.free(s);
3409     GC.free(t);
3410     GC.free(z);
3411     GC.minimize(); // release huge pool