import cstdlib = tango.stdc.stdlib;
import cstring = tango.stdc.string;
+import cstdio = tango.stdc.stdio;
/*
* This is a small optimization that proved it's usefulness. For small chunks
struct List
{
- List *next;
+ List* next;
+ Pool* pool;
}
dynarray.DynArray!(void*) roots;
dynarray.DynArray!(Range) ranges;
- dynarray.DynArray!(Pool) pools;
+ dynarray.DynArray!(Pool*) pools;
Stats stats;
}
if (i == 0)
assert(gc.min_addr == pool.baseAddr);
if (i + 1 < gc.pools.length)
- assert(*pool < gc.pools[i + 1]);
+ assert(*pool < *gc.pools[i + 1]);
else if (i + 1 == gc.pools.length)
assert(gc.max_addr == pool.topAddr);
}
assert(gc.ranges[i].pbot <= gc.ranges[i].ptop);
}
- 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 p = cast(byte*) list;
+ assert (p >= list.pool.baseAddr);
+ assert (p < list.pool.topAddr);
}
+ }
}
return true;
}
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.attr = getAttr(pool, cast(size_t)(info.base - pool.baseAddr) / 16u);
if (has_pointermap(info.attr)) {
{
size_t n;
size_t pn;
- Pool* pool;
+ Pool* pool;
for (n = 0; n < gc.pools.length; n++)
{
if (pn < pool.npages)
continue;
pool.Dtor();
+ cstdlib.free(pool);
gc.pools.remove_at(n);
n--;
}
* Allocate a chunk of memory that is larger than a page.
* Return null if out of memory.
*/
-void *bigAlloc(size_t size)
+void* bigAlloc(size_t size, out Pool* pool)
{
- Pool* pool;
size_t npages;
size_t n;
size_t pn;
npages = n;
}
- Pool p;
- p.initialize(npages);
- if (!p.baseAddr)
+ auto pool = cast(Pool*) cstdlib.calloc(1, Pool.sizeof);
+ if (pool is null)
+ return null;
+ pool.initialize(npages);
+ if (!pool.baseAddr)
{
- p.Dtor();
+ pool.Dtor();
return null;
}
- Pool* pool = gc.pools.insert_sorted(p);
- if (pool)
- {
- gc.min_addr = gc.pools[0].baseAddr;
- gc.max_addr = gc.pools[gc.pools.length - 1].topAddr;
+ auto inserted_pool = *gc.pools.insert_sorted!("*a < *b")(pool);
+ if (inserted_pool is null) {
+ pool.Dtor();
+ return null;
}
+ assert (inserted_pool is pool);
+ gc.min_addr = gc.pools[0].baseAddr;
+ gc.max_addr = gc.pools[gc.pools.length - 1].topAddr;
return pool;
}
// Convert page to free list
size_t size = binsize[bin];
- List **b = &gc.free_list[bin];
+ auto list_head = &gc.free_list[bin];
p = pool.baseAddr + pn * PAGESIZE;
ptop = p + PAGESIZE;
for (; p < ptop; p += size)
{
- (cast(List *)p).next = *b;
- *b = cast(List *)p;
+ List* l = cast(List *) p;
+ l.next = *list_head;
+ l.pool = pool;
+ *list_head = l;
}
return 1;
}
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;
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];
+ // Cache B_PAGE, B_PAGEPLUS and B_FREE lookups
+ if (bin >= B_PAGE)
+ pcache = cast(size_t)p & ~(PAGESIZE-1);
+
// 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
while (cast(Bins)pool.pagetable[pn] == B_PAGEPLUS);
bit_i = pn * (PAGESIZE / 16);
}
- else
- {
- // Don't mark bits in B_FREE pages
+ else // Don't mark bits in B_FREE pages
continue;
- }
-
- if (bin >= B_PAGE) // Cache B_PAGE and B_PAGEPLUS lookups
- pcache = cast(size_t)p & ~(PAGESIZE-1);
if (!pool.mark.test(bit_i))
{
if (!pool.noscan.test(bit_i))
{
pool.scan.set(bit_i);
- changes = 1;
+ changes = true;
}
}
}
gc.stats.world_stopped();
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) {
{
debug(COLLECT_PRINTF) printf("\tmark()\n");
- gc.p_cache = null;
- gc.size_cache = 0;
-
gc.any_changes = false;
for (size_t n = 0; n < gc.pools.length; n++)
{
{
for (List *list = gc.free_list[n]; list; list = list.next)
{
- Pool* pool = findPool(list);
- assert(pool);
- pool.freebits.set(cast(size_t)(cast(byte*)list - pool.baseAddr) / 16);
+ 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);
}
}
{
// Free up everything not marked
debug(COLLECT_PRINTF) printf("\tsweep\n");
+ gc.p_cache = null;
+ gc.size_cache = 0;
size_t freedpages = 0;
size_t freed = 0;
for (size_t n = 0; n < gc.pools.length; n++)
{
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(cast(List *)sentinel_add(p), false/*gc.no_stack > 0*/);
+ rt_finalize(sentinel_add(p), false/*gc.no_stack > 0*/);
else
- rt_finalize(cast(List *)p, false/*gc.no_stack > 0*/);
+ rt_finalize(p, false/*gc.no_stack > 0*/);
}
clrAttr(pool, bit_i, BlkAttr.ALL_BITS);
- List *list = cast(List *)p;
-
if (opts.options.mem_stomp)
memset(p, 0xF3, size);
}
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(cast(List *)sentinel_add(p), false/*gc.no_stack > 0*/);
+ rt_finalize(sentinel_add(p), false/*gc.no_stack > 0*/);
else
- rt_finalize(cast(List *)p, false/*gc.no_stack > 0*/);
+ rt_finalize(p, false/*gc.no_stack > 0*/);
}
clrAttr(pool, bit_i, BlkAttr.ALL_BITS);
- List *list = cast(List *)p;
-
if (opts.options.mem_stomp)
memset(p, 0xF3, size);
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
bit_i = bit_base + u / 16;
if (pool.freebits.test(bit_i))
{
- List *list = cast(List *)(p + u);
- // avoid unnecessary writes
+ assert ((p+u) >= pool.baseAddr);
+ assert ((p+u) < pool.topAddr);
+ List* list = cast(List*) (p + u);
+ // avoid unnecesary writes (it really saves time)
if (list.next != gc.free_list[bin])
list.next = gc.free_list[bin];
+ if (list.pool != pool)
+ list.pool = pool;
gc.free_list[bin] = list;
}
}
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;
-// if (pool.nomove.nbits &&
-// pool.nomove.test(bit_i))
+// if (pool.nomove.test(bit_i))
// attrs |= BlkAttr.NO_MOVE;
return attrs;
}
{
if (mask & BlkAttr.FINALIZE)
{
- if (!pool.finals.nbits)
- pool.finals.alloc(pool.mark.nbits);
pool.finals.set(bit_i);
}
if (mask & BlkAttr.NO_SCAN)
}
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);
lastbin = bin;
}
- size_t capacity; // to figure out where to store the bitmask
+ Pool* pool = void;
+ size_t capacity = void; // to figure out where to store the bitmask
if (bin < B_PAGE)
{
p = gc.free_list[bin];
if (!gc.free_list[bin] && !allocPage(bin))
{
newPool(1); // allocate new pool to find a new page
+ // TODO: hint allocPage() to use the pool we just created
int result = allocPage(bin);
if (!result)
onOutOfMemoryError();
capacity = binsize[bin];
// Return next item from free list
- gc.free_list[bin] = (cast(List*)p).next;
+ List* list = cast(List*) p;
+ assert ((cast(byte*)list) >= list.pool.baseAddr);
+ assert ((cast(byte*)list) < list.pool.topAddr);
+ gc.free_list[bin] = list.next;
+ pool = list.pool;
if (!(attrs & BlkAttr.NO_SCAN))
memset(p + size, 0, capacity - size);
if (opts.options.mem_stomp)
}
else
{
- p = bigAlloc(size);
+ p = bigAlloc(size, pool);
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;
}
if (attrs)
- {
- Pool *pool = findPool(p);
- assert(pool);
-
setAttr(pool, cast(size_t)(p - pool.baseAddr) / 16, attrs);
- }
+
return p;
}
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);
+ // 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 + (PAGESIZE * newsz) -
- pm_bitmask_size);
+ auto end_of_blk = cast(size_t**)(blk_base_addr +
+ new_blk_size - pm_bitmask_size);
*end_of_blk = pm_bitmask;
}
return p;
- pm_bitmask_size);
memset(pool.pagetable + pagenum +
psz, B_PAGEPLUS, newsz - psz);
+ auto new_blk_size = (PAGESIZE * newsz);
+ // 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 +
- (PAGESIZE * newsz) -
+ blk_base_addr + new_blk_size -
pm_bitmask_size);
*end_of_blk = pm_bitmask;
}
memset(pool.pagetable + pagenum + psz, B_PAGEPLUS, sz);
gc.p_cache = null;
gc.size_cache = 0;
+ // 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 (opts.options.mem_stomp)
memset(p, 0xF2, npages * PAGESIZE);
pool.freePages(pagenum, npages);
+ // just in case we were caching this pointer
+ pool.clear_cache(p);
}
else
{
// Add to free list
- List *list = cast(List*)p;
+ List* list = cast(List*) p;
if (opts.options.mem_stomp)
memset(p, 0xF2, binsize[bin]);
list.next = gc.free_list[bin];
+ list.pool = pool;
gc.free_list[bin] = list;
}
}
if (bin < B_PAGE)
{
// Check that p is not on a free list
- List *list;
-
- for (list = gc.free_list[bin]; list; list = list.next)
+ for (List* list = gc.free_list[bin]; list; list = list.next)
{
assert(cast(void*)list != p);
}
for (n = 0; n < B_PAGE; n++)
{
- for (List *list = gc.free_list[n]; list; list = list.next)
+ for (List* list = gc.free_list[n]; list; list = list.next)
flsize += binsize[n];
}
size_t cached_size;
void* cached_ptr;
- void clear_cache()
+ void clear_cache(void* ptr = null)
+ {
+ 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 = null;
- this.cached_size = 0;
+ this.cached_ptr = ptr;
+ this.cached_size = size;
}
void initialize(size_t npages)
npages = 0;
poolsize = 0;
}
- //assert(baseAddr);
topAddr = baseAddr + poolsize;
size_t nbits = cast(size_t)poolsize / 16;
projects / software / dgc / cdgc.git / blobdiff