int BTC_cust_box_mark(void *p, struct NewGC *gc)
{
if (gc->doing_memory_accounting) {
return OBJPTR_TO_OBJHEAD(p)->size;
}
return gc->mark_table[btc_redirect_cust_box](p, gc);
}
inline static void BTC_memory_account_mark(NewGC *gc, mpage *page, void *ptr)
{
GCDEBUG((DEBUGOUTF, "BTC_memory_account_mark: %p/%p\n", page, ptr));
if(page->size_class) {
if(page->size_class > 1) {
/* big page */
objhead *info = BIG_PAGE_TO_OBJHEAD(page);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, gcBYTES_TO_WORDS(page->size));
push_ptr(gc, TAG_AS_BIG_PAGE_PTR(ptr));
}
} else {
/* medium page */
objhead *info = MED_OBJHEAD(ptr, page->size);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, info->size);
ptr = OBJHEAD_TO_OBJPTR(info);
push_ptr(gc, ptr);
}
}
} else {
objhead *info = OBJPTR_TO_OBJHEAD(ptr);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, info->size);
push_ptr(gc, ptr);
}
}
}
int BTC_custodian_mark(void *p, struct NewGC *gc)
{
if (gc->doing_memory_accounting) {
if(custodian_to_owner_set(gc, p) == gc->current_mark_owner)
return gc->mark_table[btc_redirect_custodian](p, gc);
else
return OBJPTR_TO_OBJHEAD(p)->size;
}
return gc->mark_table[btc_redirect_custodian](p, gc);
}
inline static void BTC_memory_account_mark(NewGC *gc, mpage *page, void *ptr, int is_a_master_page)
{
GCDEBUG((DEBUGOUTF, "BTC_memory_account_mark: %p/%p\n", page, ptr));
/* In the case of is_a_master_page, whether this place is charged is
a little random: there's no guarantee that the btc_mark values
are in sync, and there are races among places. Approximations are
ok for accounting, though, as long as the probably for completely
wrong accounting is very low.
At the same time, we need to synchronize enough so that two
places with different new_btc_mark values don't send each other
into infinite loops (with the btc_mark value bouncing back and
forth) or overcounting. We synchronize enough by having a single
new_btc_mark value for master pages, and we stall if the value
isn't what this place wants. */
if (is_a_master_page)
check_master_btc_mark(gc, page);
if(page->size_class) {
if(page->size_class > 1) {
/* big page */
objhead *info = BIG_PAGE_TO_OBJHEAD(page);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, gcBYTES_TO_WORDS(page->size), is_a_master_page);
push_ptr(gc, TAG_AS_BIG_PAGE_PTR(ptr));
}
} else {
/* medium page */
objhead *info = MED_OBJHEAD(ptr, page->size);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, info->size, is_a_master_page);
ptr = OBJHEAD_TO_OBJPTR(info);
push_ptr(gc, ptr);
}
}
} else {
objhead *info = OBJPTR_TO_OBJHEAD(ptr);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, info->size, 0);
push_ptr(gc, ptr);
}
}
}
int GC_is_live(void *p)
{
NewGC *gc = GC_get_GC();
mpage *page = pagemap_find_page(gc->page_maps, p);
if (!page) { /* NOT GC ALLOCATED */
printf("%p page: %p NOT GC ALLOCATED\n", p, page);
fflush(stdout);
return 0;
}
else if (page->generation == 0) {
if (page == gc->gen0.curr_alloc_page) {
if (p < (void*) GC_gen0_alloc_page_ptr) {
printf("GEN0 object %p page: %p gen: %i class: %i ALIVE\n", p, page, page->generation, page->size_class);
printf("%p BEGIN: %p ALLOCED_UPTO: %p END: %p\n", p, (void*) gc->gen0.curr_alloc_page->addr, (void*) GC_gen0_alloc_page_ptr, (void*) GC_gen0_alloc_page_end);
fflush(stdout);
return 1;
}
else {
printf("GEN0 object %p page: %p gen: %i class: %i DEAD\n", p, page, page->generation, page->size_class);
printf("%p BEGIN: %p ALLOCED_UPTO: %p END: %p\n", p, (void*) gc->gen0.curr_alloc_page->addr, (void*) GC_gen0_alloc_page_ptr, (void*) GC_gen0_alloc_page_end);
fflush(stdout);
return 0;
}
}
return NUM(p) < (NUM(page->addr) + page->size);
}
else { /* page->generation */
if (page->size_class == 1) {
int dead = OBJPTR_TO_OBJHEAD(p)->dead;
printf("MEDIUM object %p page: %p gen: %i class: %i dead: %i\n", p, page, page->generation, page->size_class, dead);
fflush(stdout);
return !dead;
}
else if((NUM(page->addr) + page->size) > NUM(p)) {
printf("%p page: %p gen: %i class: %i ALIVE\n", p, page, page->generation, page->size_class);
printf("%p BEGIN: %p ALLOCED_UPTO: %p\n", p, (void*) page->addr, (void*) (NUM(page->addr) + page->size));
fflush(stdout);
return 1;
}
else {
printf("%p page: %p gen: %i class: %i DEAD\n", p, page, page->generation, page->size_class);
printf("%p BEGIN: %p ALLOCED_UPTO: %p\n", p, (void*) page->addr, (void*) (NUM(page->addr) + page->size));
fflush(stdout);
return 0;
}
}
}
inline static void BTC_memory_account_mark(NewGC *gc, mpage *page, void *ptr, int is_a_master_page)
{
GCDEBUG((DEBUGOUTF, "BTC_memory_account_mark: %p/%p\n", page, ptr));
/* In the case of is_a_master_page, whether this place is charged is
a little random: there's no guarantee that the btc_mark values are
in sync, and there are races among places. Approximations are ok for
accounting, though, as long as the probably for completely wrong
accounting is very low. */
if(page->size_class) {
if(page->size_class > 1) {
/* big page */
objhead *info = BIG_PAGE_TO_OBJHEAD(page);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, gcBYTES_TO_WORDS(page->size), is_a_master_page);
push_ptr(gc, TAG_AS_BIG_PAGE_PTR(ptr));
}
} else {
/* medium page */
objhead *info = MED_OBJHEAD(ptr, page->size);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, info->size, is_a_master_page);
ptr = OBJHEAD_TO_OBJPTR(info);
push_ptr(gc, ptr);
}
}
} else {
objhead *info = OBJPTR_TO_OBJHEAD(ptr);
if(info->btc_mark == gc->old_btc_mark) {
info->btc_mark = gc->new_btc_mark;
account_memory(gc, gc->current_mark_owner, info->size, 0);
push_ptr(gc, ptr);
}
}
}
