suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reduced all THREAD local GC usage to NewGC *gc = GC; to be replaces with GC_get_GC()

Browse Source 
svn: r12306
This commit is contained in:
Kevin Tew 2008-11-05 21:10:21 +00:00
parent 1d5d7ea18f
commit 4b29ac09c3
9 changed files with 550 additions and 508 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

300
src/mzscheme/gc2/blame_the_child.c
View File

@ -8,51 +8,53 @@
/*****************************************************************************/
/* thread list */
/*****************************************************************************/
inline static int current_owner(Scheme_Custodian *c);
inline static int current_owner(NewGC *gc, Scheme_Custodian *c);
inline static void BTC_register_new_thread(void *t, void *c)
{
NewGC *gc = GC;
GC_Thread_Info *work;
work = (GC_Thread_Info *)malloc(sizeof(GC_Thread_Info));
((Scheme_Thread *)t)->gc_info = work;
work->owner = current_owner((Scheme_Custodian *)c);
work->owner = current_owner(gc, (Scheme_Custodian *)c);
work->thread = t;
work->next = GC->thread_infos;
GC->thread_infos = work;
work->next = gc->thread_infos;
gc->thread_infos = work;
}
inline static void BTC_register_thread(void *t, void *c)
{
NewGC *gc = GC;
GC_Thread_Info *work;
work = ((Scheme_Thread *)t)->gc_info;
work->owner = current_owner((Scheme_Custodian *)c);
work->owner = current_owner(gc, (Scheme_Custodian *)c);
}
inline static void mark_threads(int owner)
inline static void mark_threads(NewGC *gc, int owner)
{
GC_Thread_Info *work;
for(work = GC->thread_infos; work; work = work->next)
for(work = gc->thread_infos; work; work = work->next)
if(work->owner == owner) {
if (((Scheme_Thread *)work->thread)->running) {
GC->normal_thread_mark(work->thread);
gc->normal_thread_mark(work->thread);
if (work->thread == scheme_current_thread) {
GC_mark_variable_stack(GC_variable_stack, 0, get_stack_base(), NULL);
GC_mark_variable_stack(GC_variable_stack, 0, get_stack_base(gc), NULL);
}
}
}
}
inline static void clean_up_thread_list(void)
inline static void clean_up_thread_list(NewGC *gc)
{
GC_Thread_Info *work = GC->thread_infos;
GC_Thread_Info *work = gc->thread_infos;
GC_Thread_Info *prev = NULL;
while(work) {
if(!pagemap_find_page(GC->page_maps, work->thread) || marked(work->thread)) {
if(!pagemap_find_page(gc->page_maps, work->thread) || marked(gc, work->thread)) {
work->thread = GC_resolve(work->thread);
prev = work;
work = work->next;
@ -60,7 +62,7 @@ inline static void clean_up_thread_list(void)
GC_Thread_Info *next = work->next;
if(prev) prev->next = next;
if(!prev) GC->thread_infos = next;
if(!prev) gc->thread_infos = next;
free(work);
work = next;
}
@ -74,11 +76,11 @@ inline static int thread_get_owner(void *p)
#define OWNER_TABLE_INIT_AMT 10
inline static int create_blank_owner_set(void)
inline static int create_blank_owner_set(NewGC *gc)
{
int i;
unsigned int curr_size = GC->owner_table_size;
OTEntry **owner_table = GC->owner_table;
unsigned int curr_size = gc->owner_table_size;
OTEntry **owner_table = gc->owner_table;
unsigned int old_size;
OTEntry **naya;
@ -97,65 +99,66 @@ inline static int create_blank_owner_set(void)
else {
curr_size *= 2;
}
GC->owner_table_size = curr_size;
gc->owner_table_size = curr_size;
naya = (OTEntry **)malloc(curr_size * sizeof(OTEntry*));
memcpy(naya, owner_table, old_size*sizeof(OTEntry*));
GC->owner_table = owner_table = naya;
gc->owner_table = owner_table = naya;
bzero(((char*)owner_table) + (sizeof(OTEntry*) * old_size),
(curr_size - old_size) * sizeof(OTEntry*));
return create_blank_owner_set();
return create_blank_owner_set(gc);
}
inline static int custodian_to_owner_set(Scheme_Custodian *cust)
inline static int custodian_to_owner_set(NewGC *gc,Scheme_Custodian *cust)
{
int i;
if (cust->gc_owner_set)
return cust->gc_owner_set;
i = create_blank_owner_set();
GC->owner_table[i]->originator = cust;
i = create_blank_owner_set(gc);
gc->owner_table[i]->originator = cust;
cust->gc_owner_set = i;
return i;
}
inline static int current_owner(Scheme_Custodian *c)
inline static int current_owner(NewGC *gc, Scheme_Custodian *c)
{
if (!scheme_current_thread)
return 1;
else if (!c)
return thread_get_owner(scheme_current_thread);
else
return custodian_to_owner_set(c);
return custodian_to_owner_set(gc, c);
}
void BTC_register_root_custodian(void *_c)
{
NewGC *gc = GC;
Scheme_Custodian *c = (Scheme_Custodian *)_c;
if (GC->owner_table) {
if (gc->owner_table) {
/* Reset */
free(GC->owner_table);
GC->owner_table = NULL;
GC->owner_table_size = 0;
free(gc->owner_table);
gc->owner_table = NULL;
gc->owner_table_size = 0;
}
if (create_blank_owner_set() != 1) {
if (create_blank_owner_set(gc) != 1) {
GCPRINT(GCOUTF, "Something extremely weird (and bad) has happened.\n");
abort();
}
GC->owner_table[1]->originator = c;
gc->owner_table[1]->originator = c;
c->gc_owner_set = 1;
}
inline static int custodian_member_owner_set(void *cust, int set)
inline static int custodian_member_owner_set(NewGC *gc, void *cust, int set)
{
Scheme_Custodian_Reference *box;
Scheme_Custodian *work = (Scheme_Custodian *) GC->owner_table[set]->originator;
Scheme_Custodian *work = (Scheme_Custodian *) gc->owner_table[set]->originator;
while(work) {
if(work == cust) return 1;
@ -165,30 +168,30 @@ inline static int custodian_member_owner_set(void *cust, int set)
return 0;
}
inline static void account_memory(int set, long amount)
inline static void account_memory(NewGC *gc, int set, long amount)
{
GC->owner_table[set]->memory_use += amount;
gc->owner_table[set]->memory_use += amount;
}
inline static void free_owner_set(int set)
inline static void free_owner_set(NewGC *gc, int set)
{
OTEntry **owner_table = GC->owner_table;
OTEntry **owner_table = gc->owner_table;
if(owner_table[set]) {
free(owner_table[set]);
}
owner_table[set] = NULL;
}
inline static void clean_up_owner_table(void)
inline static void clean_up_owner_table(NewGC *gc)
{
OTEntry **owner_table = GC->owner_table;
const int table_size = GC->owner_table_size;
OTEntry **owner_table = gc->owner_table;
const int table_size = gc->owner_table_size;
int i;
for(i = 1; i < table_size; i++)
if(owner_table[i]) {
/* repair or delete the originator */
if(!marked(owner_table[i]->originator)) {
if(!marked(gc, owner_table[i]->originator)) {
owner_table[i]->originator = NULL;
} else
owner_table[i]->originator = GC_resolve(owner_table[i]->originator);
@ -196,53 +199,54 @@ inline static void clean_up_owner_table(void)
/* potential delete */
if(i != 1)
if((owner_table[i]->memory_use == 0) && !owner_table[i]->originator)
free_owner_set(i);
free_owner_set(gc, i);
}
}
inline static unsigned long custodian_usage(void *custodian)
{
OTEntry **owner_table = GC->owner_table;
const int table_size = GC->owner_table_size;
NewGC *gc = GC;
OTEntry **owner_table = gc->owner_table;
const int table_size = gc->owner_table_size;
unsigned long retval = 0;
int i;
if(!GC->really_doing_accounting) {
GC->park[0] = custodian;
GC->really_doing_accounting = 1;
if(!gc->really_doing_accounting) {
gc->park[0] = custodian;
gc->really_doing_accounting = 1;
garbage_collect(1);
custodian = GC->park[0];
GC->park[0] = NULL;
custodian = gc->park[0];
gc->park[0] = NULL;
}
for(i = 1; i < table_size; i++)
if(owner_table[i] && custodian_member_owner_set(custodian, i))
if(owner_table[i] && custodian_member_owner_set(gc, custodian, i))
retval += owner_table[i]->memory_use;
return gcWORDS_TO_BYTES(retval);
}
inline static void BTC_memory_account_mark(struct mpage *page, void *ptr)
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->big_page) {
struct objhead *info = (struct objhead *)(NUM(page->addr) + PREFIX_SIZE);
if(info->btc_mark == GC->old_btc_mark) {
info->btc_mark = GC->new_btc_mark;
account_memory(GC->current_mark_owner, gcBYTES_TO_WORDS(page->size));
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(ptr);
}
} else {
struct objhead *info = (struct objhead *)((char*)ptr - WORD_SIZE);
if(info->btc_mark == GC->old_btc_mark) {
info->btc_mark = GC->new_btc_mark;
account_memory(GC->current_mark_owner, info->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);
push_ptr(ptr);
}
}
}
inline static void mark_cust_boxes(Scheme_Custodian *cur)
inline static void mark_cust_boxes(NewGC *gc, Scheme_Custodian *cur)
{
Scheme_Object *pr, *prev = NULL, *next;
GC_Weak_Box *wb;
@ -254,7 +258,7 @@ inline static void mark_cust_boxes(Scheme_Custodian *cur)
wb = (GC_Weak_Box *)SCHEME_CAR(pr);
next = SCHEME_CDR(pr);
if (wb->val) {
GC->normal_cust_box_mark(wb->val);
gc->normal_cust_box_mark(wb->val);
prev = pr;
} else {
if (prev)
@ -274,8 +278,9 @@ int BTC_thread_mark(void *p)
int BTC_custodian_mark(void *p)
{
if(custodian_to_owner_set(p) == GC->current_mark_owner)
return GC->normal_custodian_mark(p);
NewGC *gc = GC;
if(custodian_to_owner_set(gc, p) == gc->current_mark_owner)
return gc->normal_custodian_mark(p);
else
return ((struct objhead *)(NUM(p) - WORD_SIZE))->size;
}
@ -285,7 +290,7 @@ int BTC_cust_box_mark(void *p)
return ((struct objhead *)(NUM(p) - WORD_SIZE))->size;
}
inline static void mark_normal_obj(struct mpage *page, void *ptr)
inline static void mark_normal_obj(NewGC *gc, mpage *page, void *ptr)
{
switch(page->page_type) {
case PAGE_TAGGED: {
@ -295,7 +300,7 @@ inline static void mark_normal_obj(struct mpage *page, void *ptr)
ignore them outright. In the case of custodians, we do need
to do the check; those differences are handled by replacing
the mark procedure in mark_table. */
GC->mark_table[*(unsigned short*)ptr](ptr);
gc->mark_table[*(unsigned short*)ptr](ptr);
break;
}
case PAGE_ATOMIC: break;
@ -311,14 +316,14 @@ inline static void mark_normal_obj(struct mpage *page, void *ptr)
unsigned short tag = *(unsigned short*)ptr;
void **temp = ptr, **end = PPTR(info) + (info->size - INSET_WORDS);
while(temp < end) temp += GC->mark_table[tag](temp);
while(temp < end) temp += gc->mark_table[tag](temp);
break;
}
case PAGE_XTAGGED: GC_mark_xtagged(ptr); break;
}
}
inline static void mark_acc_big_page(struct mpage *page)
inline static void mark_acc_big_page(NewGC *gc, mpage *page)
{
void **start = PPTR(NUM(page->addr) + PREFIX_SIZE + WORD_SIZE);
void **end = PPTR(NUM(page->addr) + page->size);
@ -327,10 +332,10 @@ inline static void mark_acc_big_page(struct mpage *page)
case PAGE_TAGGED:
{
unsigned short tag = *(unsigned short*)start;
if((unsigned long)GC->mark_table[tag] < PAGE_TYPES) {
if((unsigned long)gc->mark_table[tag] < PAGE_TYPES) {
/* atomic */
} else
GC->mark_table[tag](start); break;
gc->mark_table[tag](start); break;
}
case PAGE_ATOMIC: break;
case PAGE_ARRAY: while(start < end) gcMARK(*(start++)); break;
@ -338,63 +343,63 @@ inline static void mark_acc_big_page(struct mpage *page)
case PAGE_TARRAY: {
unsigned short tag = *(unsigned short *)start;
end -= INSET_WORDS;
while(start < end) start += GC->mark_table[tag](start);
while(start < end) start += gc->mark_table[tag](start);
break;
}
}
}
static void btc_overmem_abort()
static void btc_overmem_abort(NewGC *gc)
{
GC->kill_propagation_loop = 1;
gc->kill_propagation_loop = 1;
GCWARN((GCOUTF, "WARNING: Ran out of memory accounting. "
"Info will be wrong.\n"));
}
static void propagate_accounting_marks(void)
static void propagate_accounting_marks(NewGC *gc)
{
struct mpage *page;
void *p;
PageMap pagemap = GC->page_maps;
while(pop_ptr(&p) && !GC->kill_propagation_loop) {
PageMap pagemap = gc->page_maps;
while(pop_ptr(&p) && !gc->kill_propagation_loop) {
page = pagemap_find_page(pagemap, p);
set_backtrace_source(p, page->page_type);
GCDEBUG((DEBUGOUTF, "btc_account: popped off page %p:%p, ptr %p\n", page, page->addr, p));
if(page->big_page)
mark_acc_big_page(page);
mark_acc_big_page(gc, page);
else
mark_normal_obj(page, p);
mark_normal_obj(gc, page, p);
}
if(GC->kill_propagation_loop)
if(gc->kill_propagation_loop)
reset_pointer_stack();
}
static void BTC_do_accounting(void)
static void BTC_do_accounting(NewGC *gc)
{
const int table_size = GC->owner_table_size;
OTEntry **owner_table = GC->owner_table;
const int table_size = gc->owner_table_size;
OTEntry **owner_table = gc->owner_table;
if(GC->really_doing_accounting) {
Scheme_Custodian *cur = owner_table[current_owner(NULL)]->originator;
if(gc->really_doing_accounting) {
Scheme_Custodian *cur = owner_table[current_owner(gc, NULL)]->originator;
Scheme_Custodian_Reference *box = cur->global_next;
int i;
GCDEBUG((DEBUGOUTF, "\nBEGINNING MEMORY ACCOUNTING\n"));
GC->doing_memory_accounting = 1;
GC->in_unsafe_allocation_mode = 1;
GC->unsafe_allocation_abort = btc_overmem_abort;
gc->doing_memory_accounting = 1;
gc->in_unsafe_allocation_mode = 1;
gc->unsafe_allocation_abort = btc_overmem_abort;
if(!GC->normal_thread_mark) {
GC->normal_thread_mark = GC->mark_table[scheme_thread_type];
GC->normal_custodian_mark = GC->mark_table[scheme_custodian_type];
GC->normal_cust_box_mark = GC->mark_table[GC->cust_box_tag];
if(!gc->normal_thread_mark) {
gc->normal_thread_mark = gc->mark_table[scheme_thread_type];
gc->normal_custodian_mark = gc->mark_table[scheme_custodian_type];
gc->normal_cust_box_mark = gc->mark_table[gc->cust_box_tag];
}
GC->mark_table[scheme_thread_type] = BTC_thread_mark;
GC->mark_table[scheme_custodian_type] = BTC_custodian_mark;
GC->mark_table[GC->ephemeron_tag] = BTC_ephemeron_mark;
GC->mark_table[GC->cust_box_tag] = BTC_cust_box_mark;
gc->mark_table[scheme_thread_type] = BTC_thread_mark;
gc->mark_table[scheme_custodian_type] = BTC_custodian_mark;
gc->mark_table[gc->ephemeron_tag] = BTC_ephemeron_mark;
gc->mark_table[gc->cust_box_tag] = BTC_cust_box_mark;
/* clear the memory use numbers out */
for(i = 1; i < table_size; i++)
@ -409,28 +414,28 @@ static void BTC_do_accounting(void)
/* walk backwards for the order we want */
while(cur) {
int owner = custodian_to_owner_set(cur);
int owner = custodian_to_owner_set(gc, cur);
GC->current_mark_owner = owner;
gc->current_mark_owner = owner;
GCDEBUG((DEBUGOUTF,"MARKING THREADS OF OWNER %i (CUST %p)\n", owner, cur));
GC->kill_propagation_loop = 0;
mark_threads(owner);
mark_cust_boxes(cur);
gc->kill_propagation_loop = 0;
mark_threads(gc, owner);
mark_cust_boxes(gc, cur);
GCDEBUG((DEBUGOUTF, "Propagating accounting marks\n"));
propagate_accounting_marks();
propagate_accounting_marks(gc);
box = cur->global_prev; cur = box ? SCHEME_PTR1_VAL(box) : NULL;
}
GC->mark_table[scheme_thread_type] = GC->normal_thread_mark;
GC->mark_table[scheme_custodian_type] = GC->normal_custodian_mark;
GC->mark_table[GC->ephemeron_tag] = mark_ephemeron;
GC->mark_table[GC->cust_box_tag] = GC->normal_cust_box_mark;
gc->mark_table[scheme_thread_type] = gc->normal_thread_mark;
gc->mark_table[scheme_custodian_type] = gc->normal_custodian_mark;
gc->mark_table[gc->ephemeron_tag] = mark_ephemeron;
gc->mark_table[gc->cust_box_tag] = gc->normal_cust_box_mark;
GC->in_unsafe_allocation_mode = 0;
GC->doing_memory_accounting = 0;
GC->old_btc_mark = GC->new_btc_mark;
GC->new_btc_mark = !GC->new_btc_mark;
gc->in_unsafe_allocation_mode = 0;
gc->doing_memory_accounting = 0;
gc->old_btc_mark = gc->new_btc_mark;
gc->new_btc_mark = !gc->new_btc_mark;
}
clear_stack_pages();
@ -438,23 +443,24 @@ static void BTC_do_accounting(void)
inline static void BTC_add_account_hook(int type,void *c1,void *c2,unsigned long b)
{
NewGC *gc = GC;
AccountHook *work;
if(!GC->really_doing_accounting) {
GC->park[0] = c1;
GC->park[1] = c2;
GC->really_doing_accounting = 1;
if(!gc->really_doing_accounting) {
gc->park[0] = c1;
gc->park[1] = c2;
gc->really_doing_accounting = 1;
garbage_collect(1);
c1 = GC->park[0]; GC->park[0] = NULL;
c2 = GC->park[1]; GC->park[1] = NULL;
c1 = gc->park[0]; gc->park[0] = NULL;
c2 = gc->park[1]; gc->park[1] = NULL;
}
if (type == MZACCT_LIMIT)
GC->reset_limits = 1;
gc->reset_limits = 1;
if (type == MZACCT_REQUIRE)
GC->reset_required = 1;
gc->reset_required = 1;
for(work = GC->hooks; work; work = work->next) {
for(work = gc->hooks; work; work = work->next) {
if((work->type == type) && (work->c2 == c2) && (work->c1 == c1)) {
if(type == MZACCT_REQUIRE) {
if(b > work->amount) work->amount = b;
@ -473,18 +479,18 @@ inline static void BTC_add_account_hook(int type,void *c1,void *c2,unsigned long
work->amount = b;
/* push work onto hooks */
work->next = GC->hooks;
GC->hooks = work;
work->next = gc->hooks;
gc->hooks = work;
}
}
inline static void clean_up_account_hooks()
inline static void clean_up_account_hooks(NewGC *gc)
{
AccountHook *work = GC->hooks;
AccountHook *work = gc->hooks;
AccountHook *prev = NULL;
while(work) {
if((!work->c1 || marked(work->c1)) && marked(work->c2)) {
if((!work->c1 || marked(gc, work->c1)) && marked(gc, work->c2)) {
work->c1 = GC_resolve(work->c1);
work->c2 = GC_resolve(work->c2);
prev = work;
@ -494,34 +500,34 @@ inline static void clean_up_account_hooks()
AccountHook *next = work->next;
if(prev) prev->next = next;
if(!prev) GC->hooks = next;
if(!prev) gc->hooks = next;
free(work);
work = next;
}
}
}
static unsigned long custodian_super_require(void *c)
static unsigned long custodian_super_require(NewGC *gc, void *c)
{
int set = ((Scheme_Custodian *)c)->gc_owner_set;
const int table_size = GC->owner_table_size;
OTEntry **owner_table = GC->owner_table;
const int table_size = gc->owner_table_size;
OTEntry **owner_table = gc->owner_table;
if (GC->reset_required) {
if (gc->reset_required) {
int i;
for(i = 1; i < table_size; i++)
if (owner_table[i])
owner_table[i]->required_set = 0;
GC->reset_required = 0;
gc->reset_required = 0;
}
if (!owner_table[set]->required_set) {
unsigned long req = 0, r;
AccountHook *work = GC->hooks;
AccountHook *work = gc->hooks;
while(work) {
if ((work->type == MZACCT_REQUIRE) && (c == work->c2)) {
r = work->amount + custodian_super_require(work->c1);
r = work->amount + custodian_super_require(gc, work->c1);
if (r > req)
req = r;
}
@ -534,23 +540,23 @@ static unsigned long custodian_super_require(void *c)
return owner_table[set]->super_required;
}
inline static void BTC_run_account_hooks()
inline static void BTC_run_account_hooks(NewGC *gc)
{
AccountHook *work = GC->hooks;
AccountHook *work = gc->hooks;
AccountHook *prev = NULL;
while(work) {
if( ((work->type == MZACCT_REQUIRE) &&
((GC->used_pages > (GC->max_pages_for_use / 2))
|| ((((GC->max_pages_for_use / 2) - GC->used_pages) * APAGE_SIZE)
< (work->amount + custodian_super_require(work->c1)))))
((gc->used_pages > (gc->max_pages_for_use / 2))
|| ((((gc->max_pages_for_use / 2) - gc->used_pages) * APAGE_SIZE)
< (work->amount + custodian_super_require(gc, work->c1)))))
||
((work->type == MZACCT_LIMIT) &&
(GC_get_memory_use(work->c1) > work->amount))) {
AccountHook *next = work->next;
if(prev) prev->next = next;
if(!prev) GC->hooks = next;
if(!prev) gc->hooks = next;
scheme_schedule_custodian_close(work->c2);
free(work);
work = next;
@ -561,27 +567,27 @@ inline static void BTC_run_account_hooks()
}
}
static unsigned long custodian_single_time_limit(int set)
static unsigned long custodian_single_time_limit(NewGC *gc, int set)
{
OTEntry **owner_table = GC->owner_table;
const int table_size = GC->owner_table_size;
OTEntry **owner_table = gc->owner_table;
const int table_size = gc->owner_table_size;
if (!set)
return (unsigned long)(long)-1;
if (GC->reset_limits) {
if (gc->reset_limits) {
int i;
for(i = 1; i < table_size; i++)
if (owner_table[i])
owner_table[i]->limit_set = 0;
GC->reset_limits = 0;
gc->reset_limits = 0;
}
if (!owner_table[set]->limit_set) {
/* Check for limits on this custodian or one of its ancestors: */
unsigned long limit = (unsigned long)(long)-1;
Scheme_Custodian *orig = (Scheme_Custodian *) owner_table[set]->originator, *c;
AccountHook *work = GC->hooks;
AccountHook *work = gc->hooks;
while(work) {
if ((work->type == MZACCT_LIMIT) && (work->c1 == work->c2)) {
@ -618,7 +624,7 @@ long BTC_get_memory_use(void *o)
return 0;
}
int BTC_single_allocation_limit(size_t sizeb) {
int BTC_single_allocation_limit(NewGC *gc, size_t sizeb) {
/* We're allowed to fail. Check for allocations that exceed a single-time
* limit. Otherwise, the limit doesn't work as intended, because
* a program can allocate a large block that nearly exhausts memory,
@ -626,14 +632,16 @@ int BTC_single_allocation_limit(size_t sizeb) {
* is much smaller than the actual available memory, and as long as
* GC_out_of_memory protects any user-requested allocation whose size
* is independent of any existing object, then we can enforce the limit. */
return (custodian_single_time_limit(thread_get_owner(scheme_current_thread)) < sizeb);
return (custodian_single_time_limit(gc, thread_get_owner(scheme_current_thread)) < sizeb);
}
static inline void BTC_clean_up() {
clean_up_thread_list();
clean_up_owner_table();
clean_up_account_hooks();
static inline void BTC_clean_up(NewGC *gc) {
clean_up_thread_list(gc);
clean_up_owner_table(gc);
clean_up_account_hooks(gc);
}
# define BTC_set_btc_mark(x) (((struct objhead *)(x))->btc_mark = GC->old_btc_mark)
static inline void BTC_set_btc_mark(NewGC *gc, void* x) {
((struct objhead *)(x))->btc_mark = gc->old_btc_mark;
}
#endif

44
src/mzscheme/gc2/compact.c
View File

@ -18,6 +18,7 @@
#include "../src/schpriv.h"
static THREAD_LOCAL CompactGC *GC;
#define GCTYPE CompactGC
/**************** Configuration ****************/
@ -453,12 +454,14 @@ void CompactGC_initialize(CompactGC *gc) {
void GC_init_type_tags(int count, int pair, int mutable_pair, int weakbox, int ephemeron, int weakarray, int custbox)
{
CompactGC *gc;
weak_box_tag = weakbox;
ephemeron_tag = ephemeron;
weak_array_tag = weakarray;
GC = malloc(sizeof(CompactGC));
CompactGC_initialize(GC);
gc = malloc(sizeof(CompactGC));
GC = gc;
CompactGC_initialize(gc);
}
void GC_register_traversers(Type_Tag tag, Size_Proc size, Mark_Proc mark, Fixup_Proc fixup,
@ -553,7 +556,7 @@ static int size_on_free_list(void *p)
/* weak arrays and boxes */
/******************************************************************************/
static int is_marked(void *p);
static int is_marked(CompactGC *gc, void *p);
#define weak_box_resolve(p) (p)
#include "weak.c"
@ -685,7 +688,7 @@ int GC_is_allocated(void *p)
}
/* Works only during GC: */
static int is_marked(void *p)
static int is_marked(CompactGC *gc, void *p)
{
unsigned long g = ((unsigned long)p >> MAPS_SHIFT);
MPage *map;
@ -701,7 +704,7 @@ static int is_marked(void *p)
#endif
if (page->flags & MFLAG_BIGBLOCK) {
if (page->flags & MFLAG_CONTINUED)
return is_marked(page->o.bigblock_start);
return is_marked(gc, page->o.bigblock_start);
else
return (page->flags & (COLOR_MASK | MFLAG_OLD));
} else {
@ -2861,7 +2864,7 @@ static void init(void)
initialized = 1;
#if GENERATIONS
initialize_signal_handler();
initialize_signal_handler(GC);
#endif
}
}
@ -2958,6 +2961,7 @@ static void fixup_roots()
static void gcollect(int full)
{
CompactGC *gc = GC;
int did_fnls;
#if TIME
struct rusage pre, post;
@ -2977,9 +2981,9 @@ static void gcollect(int full)
set_ending_tags();
init_weak_boxes();
init_ephemerons();
init_weak_arrays();
init_weak_boxes(gc);
init_ephemerons(gc);
init_weak_arrays(gc);
did_fnls = 0;
@ -3118,7 +3122,7 @@ static void gcollect(int full)
/* Propagate, mark ready ephemerons */
propagate_all_mpages();
mark_ready_ephemerons();
mark_ready_ephemerons(gc);
/* Propagate, loop to do finalization */
while (1) {
@ -3138,7 +3142,7 @@ static void gcollect(int full)
for (f = GC->finalizers; f; f = next) {
next = f->next;
if (f->eager_level == 3) {
if (!is_marked(f->p)) {
if (!is_marked(gc, f->p)) {
/* Not yet marked. Mark it and enqueue it. */
#if RECORD_MARK_SRC
mark_src = f;
@ -3173,7 +3177,7 @@ static void gcollect(int full)
for (wl = fnl_weaks; wl; wl = wl->next) {
void *wp = (void *)wl->p;
int markit;
markit = is_marked(wp);
markit = is_marked(gc, wp);
if (markit) {
#if RECORD_MARK_SRC
mark_src = wp;
@ -3217,7 +3221,7 @@ static void gcollect(int full)
mark_src = f;
mark_type = MTYPE_TAGGED;
#endif
if (!is_marked(f->p)) {
if (!is_marked(gc, f->p)) {
/* Not yet marked. Mark content. */
if (f->tagged) {
Type_Tag tag = *(Type_Tag *)f->p;
@ -3243,7 +3247,7 @@ static void gcollect(int full)
while (f) {
if (f->eager_level == eager_level) {
if (!is_marked(f->p)) {
if (!is_marked(gc, f->p)) {
/* Not yet marked. Move finalization to run queue. */
Fnl *next = f->next;
@ -3286,7 +3290,7 @@ static void gcollect(int full)
f = f->next;
}
mark_ready_ephemerons();
mark_ready_ephemerons(gc);
}
did_fnls++;
@ -3323,9 +3327,9 @@ static void gcollect(int full)
/******************************************************/
zero_remaining_ephemerons();
zero_weak_boxes();
zero_weak_arrays();
zero_remaining_ephemerons(gc);
zero_weak_boxes(gc);
zero_weak_arrays(gc);
/* Cleanup weak finalization links: */
{
@ -3334,7 +3338,7 @@ static void gcollect(int full)
prev = NULL;
for (wl = fnl_weaks; wl; wl = next) {
next = wl->next;
if (!is_marked(wl->p)) {
if (!is_marked(gc, wl->p)) {
/* Will be collected. Removed this link. */
wl->p = NULL;
if (prev)
@ -3472,7 +3476,7 @@ static void gcollect(int full)
protect_old_mpages();
reset_finalizer_tree();
reset_finalizer_tree(GC);
#if (COMPACTING == NEVER_COMPACT)
# define THRESH_FREE_LIST_DELTA (FREE_LIST_DELTA >> LOG_WORD_SIZE)

43
src/mzscheme/gc2/fnls.c
View File

@ -26,6 +26,7 @@ void GC_set_finalizer(void *p, int tagged, int level, void (*f)(void *p, void *d
void *data, void (**oldf)(void *p, void *data),
void **olddata)
{
GCTYPE *gc = GC;
Fnl *fnl;
if (!is_finalizable_page(p)) {
@ -35,8 +36,8 @@ void GC_set_finalizer(void *p, int tagged, int level, void (*f)(void *p, void *d
return;
}
GC->splayed_finalizers = fnl_splay((unsigned long)p, GC->splayed_finalizers);
fnl = GC->splayed_finalizers;
gc->splayed_finalizers = fnl_splay((unsigned long)p, gc->splayed_finalizers);
fnl = gc->splayed_finalizers;
if (fnl && (fnl->p == p)) {
if (oldf) *oldf = fnl->f;
if (olddata) *olddata = fnl->data;
@ -49,12 +50,12 @@ void GC_set_finalizer(void *p, int tagged, int level, void (*f)(void *p, void *d
if (fnl->prev)
fnl->prev->next = fnl->next;
else
GC->finalizers = fnl->next;
gc->finalizers = fnl->next;
if (fnl->next)
fnl->next->prev = fnl->prev;
--GC->num_fnls;
GC->splayed_finalizers = fnl_splay_delete((unsigned long)p, GC->splayed_finalizers);
--gc->num_fnls;
gc->splayed_finalizers = fnl_splay_delete((unsigned long)p, gc->splayed_finalizers);
}
return;
}
@ -66,16 +67,16 @@ void GC_set_finalizer(void *p, int tagged, int level, void (*f)(void *p, void *d
return;
/* Allcation might trigger GC, so we use park: */
GC->park[0] = p;
GC->park[1] = data;
gc->park[0] = p;
gc->park[1] = data;
fnl = (Fnl *)GC_malloc_atomic(sizeof(Fnl));
memset(fnl, 0, sizeof(Fnl));
p = GC->park[0];
data = GC->park[1];
GC->park[0] = NULL;
GC->park[1] = NULL;
p = gc->park[0];
data = gc->park[1];
gc->park[0] = NULL;
gc->park[1] = NULL;
fnl->p = p;
@ -111,30 +112,30 @@ void GC_set_finalizer(void *p, int tagged, int level, void (*f)(void *p, void *d
#endif
/* push finalizer */
fnl->next = GC->finalizers;
fnl->next = gc->finalizers;
fnl->prev = NULL;
if (GC->finalizers) {
GC->finalizers->prev = fnl;
if (gc->finalizers) {
gc->finalizers->prev = fnl;
}
GC->finalizers = fnl;
gc->finalizers = fnl;
GC->splayed_finalizers = fnl_splay_insert((unsigned long)p, fnl, GC->splayed_finalizers);
gc->splayed_finalizers = fnl_splay_insert((unsigned long)p, fnl, gc->splayed_finalizers);
GC->num_fnls++;
gc->num_fnls++;
}
static void reset_finalizer_tree()
static void reset_finalizer_tree(GCTYPE *gc)
/* After a GC, rebuild the splay tree, since object addresses
have moved. */
{
Fnl *fnl;
Fnl *prev = NULL;
GC->splayed_finalizers = NULL;
gc->splayed_finalizers = NULL;
for (fnl = GC->finalizers; fnl; fnl = fnl->next) {
for (fnl = gc->finalizers; fnl; fnl = fnl->next) {
fnl->prev = prev;
GC->splayed_finalizers = fnl_splay_insert((unsigned long)fnl->p, fnl, GC->splayed_finalizers);
gc->splayed_finalizers = fnl_splay_insert((unsigned long)fnl->p, fnl, gc->splayed_finalizers);
prev = fnl;
}
}

16
src/mzscheme/gc2/immobile_boxes.c
View File

@ -3,24 +3,26 @@
/*****************************************************************************/
void **GC_malloc_immobile_box(void *p)
{
GCTYPE *gc = GC;
GC_Immobile_Box *ib = malloc(sizeof(GC_Immobile_Box));
if(!ib) GCERR((GCOUTF, "Couldn't allocate space for immobile box!\n"));
ib->p = p;
ib->next = GC->immobile_boxes;
ib->next = gc->immobile_boxes;
ib->prev = NULL;
if(ib->next) ib->next->prev = ib;
GC->immobile_boxes = ib;
gc->immobile_boxes = ib;
return (void**)ib;
}
void GC_free_immobile_box(void **b)
{
GCTYPE *gc = GC;
GC_Immobile_Box *ib;
for(ib = GC->immobile_boxes; ib; ib = ib->next)
for(ib = gc->immobile_boxes; ib; ib = ib->next)
if(PPTR(ib) == b) {
if(ib->prev) ib->prev->next = ib->next;
if(!ib->prev) GC->immobile_boxes = ib->next;
if(!ib->prev) gc->immobile_boxes = ib->next;
if(ib->next) ib->next->prev = ib->prev;
free(ib);
return;
@ -30,18 +32,18 @@ void GC_free_immobile_box(void **b)
#define traverse_immobiles(gcMUCK, set_bt_src) { \
GC_Immobile_Box *ib; \
for(ib = GC->immobile_boxes; ib; ib = ib->next) { \
for(ib = gc->immobile_boxes; ib; ib = ib->next) { \
set_bt_src(ib, BT_IMMOBILE); \
gcMUCK(ib->p); \
} \
}
inline static void mark_immobiles(void)
inline static void mark_immobiles(GCTYPE *gc)
{
traverse_immobiles(gcMARK, set_backtrace_source);
}
inline static void repair_immobiles(void)
inline static void repair_immobiles(GCTYPE *gc)
{
traverse_immobiles(gcFIXUP, two_arg_no_op);
}

518
src/mzscheme/gc2/newgc.c
View File

File diff suppressed because it is too large Load Diff

4
src/mzscheme/gc2/newgc.h
View File

@ -100,13 +100,13 @@ typedef struct NewGC {
Fnl *last_in_queue;
Weak_Finalizer *weak_finalizers;
struct NewGC *primoridal_gc;
struct GC *primoridal_gc;
unsigned long max_heap_size;
unsigned long max_pages_in_heap;
unsigned long max_pages_for_use;
unsigned long used_pages;
unsigned long actual_pages_size;
void (*unsafe_allocation_abort)();
void (*unsafe_allocation_abort)(struct NewGC *);
unsigned long memory_in_use; /* the amount of memory in use */
/* blame the child saved off Mark_Proc pointers */

3
src/mzscheme/gc2/roots.c
View File

@ -80,7 +80,8 @@ static void sort_and_merge_roots(Roots *roots)
void GC_add_roots(void *start, void *end)
{
Roots *roots = &GC->roots;
GCTYPE *gc = GC;
Roots *roots = &gc->roots;
if (roots->count >= roots->size) {
grow_roots(roots);

8
src/mzscheme/gc2/sighand.c
View File

@ -97,7 +97,7 @@ void fault_handler(int sn, siginfo_t *si, void *ctx)
/* init function */
/******************************************************************************/
static void initialize_signal_handler()
static void initialize_signal_handler(GCTYPE *gc)
{
# ifdef NEED_OSX_MACH_HANDLER
macosx_init_exception_handler();
@ -128,12 +128,12 @@ static void initialize_signal_handler()
if (aveh)
aveh(TRUE, fault_handler);
else
GC->generations_available = 0;
gc->generations_available = 0;
}
# endif
}
static void remove_signal_handler()
static void remove_signal_handler(GCTYPE *gc)
{
# ifdef NEED_OSX_MACH_HANDLER
# endif
@ -148,7 +148,7 @@ static void remove_signal_handler()
}
# endif
# ifdef NEED_SIGWIN
if (GC->generations_available) {
if (gc->generations_available) {
HMODULE hm;
ULONG (WINAPI*rveh)(gcPVECTORED_EXCEPTION_HANDLER);

94
src/mzscheme/gc2/weak.c
View File

@ -35,12 +35,13 @@ static int size_weak_array(void *p)
static int mark_weak_array(void *p)
{
GCTYPE *gc = GC;
GC_Weak_Array *a = (GC_Weak_Array *)p;
gcMARK(a->replace_val);
a->next = GC->weak_arrays;
GC->weak_arrays = a;
a->next = gc->weak_arrays;
gc->weak_arrays = a;
#if CHECKS
/* For now, weak arrays only used for symbols, keywords, and falses: */
@ -83,42 +84,43 @@ static int fixup_weak_array(void *p)
void *GC_malloc_weak_array(size_t size_in_bytes, void *replace_val)
{
GCTYPE *gc = GC;
GC_Weak_Array *w;
/* Allcation might trigger GC, so we use park: */
GC->park[0] = replace_val;
gc->park[0] = replace_val;
w = (GC_Weak_Array *)GC_malloc_one_tagged(size_in_bytes
+ sizeof(GC_Weak_Array)
- sizeof(void *));
replace_val = GC->park[0];
GC->park[0] = NULL;
replace_val = gc->park[0];
gc->park[0] = NULL;
w->type = GC->weak_array_tag;
w->type = gc->weak_array_tag;
w->replace_val = replace_val;
w->count = (size_in_bytes >> LOG_WORD_SIZE);
return w;
}
void init_weak_arrays() {
GC->weak_arrays = NULL;
static void init_weak_arrays(GCTYPE *gc) {
gc->weak_arrays = NULL;
}
static void zero_weak_arrays()
static void zero_weak_arrays(GCTYPE *gc)
{
GC_Weak_Array *wa;
int i;
wa = GC->weak_arrays;
wa = gc->weak_arrays;
while (wa) {
void **data;
data = wa->data;
for (i = wa->count; i--; ) {
void *p = data[i];
if (p && !is_marked(p))
if (p && !is_marked(gc, p))
data[i] = wa->replace_val;
}
@ -137,13 +139,14 @@ static int size_weak_box(void *p)
static int mark_weak_box(void *p)
{
GCTYPE *gc = GC;
GC_Weak_Box *wb = (GC_Weak_Box *)p;
gcMARK(wb->secondary_erase);
if (wb->val) {
wb->next = GC->weak_boxes;
GC->weak_boxes = wb;
wb->next = gc->weak_boxes;
gc->weak_boxes = wb;
}
return gcBYTES_TO_WORDS(sizeof(GC_Weak_Box));
@ -161,20 +164,21 @@ static int fixup_weak_box(void *p)
void *GC_malloc_weak_box(void *p, void **secondary, int soffset)
{
GCTYPE *gc = GC;
GC_Weak_Box *w;
/* Allcation might trigger GC, so we use park: */
GC->park[0] = p;
GC->park[1] = secondary;
gc->park[0] = p;
gc->park[1] = secondary;
w = (GC_Weak_Box *)GC_malloc_one_tagged(sizeof(GC_Weak_Box));
p = GC->park[0];
secondary = (void **)GC->park[1];
GC->park[0] = NULL;
GC->park[1] = NULL;
p = gc->park[0];
secondary = (void **)gc->park[1];
gc->park[0] = NULL;
gc->park[1] = NULL;
w->type = GC->weak_box_tag;
w->type = gc->weak_box_tag;
w->val = p;
w->secondary_erase = secondary;
w->soffset = soffset;
@ -182,17 +186,17 @@ void *GC_malloc_weak_box(void *p, void **secondary, int soffset)
return w;
}
void init_weak_boxes() {
GC->weak_boxes = NULL;
static void init_weak_boxes(GCTYPE *gc) {
gc->weak_boxes = NULL;
}
static void zero_weak_boxes()
static void zero_weak_boxes(GCTYPE *gc)
{
GC_Weak_Box *wb;
wb = GC->weak_boxes;
wb = gc->weak_boxes;
while (wb) {
if (!is_marked(wb->val)) {
if (!is_marked(gc, wb->val)) {
wb->val = NULL;
if (wb->secondary_erase) {
void **p;
@ -216,11 +220,12 @@ static int size_ephemeron(void *p)
static int mark_ephemeron(void *p)
{
GCTYPE *gc = GC;
GC_Ephemeron *eph = (GC_Ephemeron *)p;
if (eph->val) {
eph->next = GC->ephemerons;
GC->ephemerons = eph;
eph->next = gc->ephemerons;
gc->ephemerons = eph;
}
return gcBYTES_TO_WORDS(sizeof(GC_Ephemeron));
@ -251,55 +256,56 @@ static int fixup_ephemeron(void *p)
void *GC_malloc_ephemeron(void *k, void *v)
{
GCTYPE *gc = GC;
GC_Ephemeron *eph;
/* Allcation might trigger GC, so we use park: */
GC->park[0] = k;
GC->park[1] = v;
gc->park[0] = k;
gc->park[1] = v;
eph = (GC_Ephemeron *)GC_malloc_one_tagged(sizeof(GC_Ephemeron));
k = GC->park[0];
v = GC->park[1];
GC->park[0] = NULL;
GC->park[1] = NULL;
k = gc->park[0];
v = gc->park[1];
gc->park[0] = NULL;
gc->park[1] = NULL;
eph->type = GC->ephemeron_tag;
eph->type = gc->ephemeron_tag;
eph->key = k;
eph->val = v;
return eph;
}
void init_ephemerons() {
GC->ephemerons = NULL;
GC->num_last_seen_ephemerons = 0;
void init_ephemerons(GCTYPE *gc) {
gc->ephemerons = NULL;
gc->num_last_seen_ephemerons = 0;
}
static void mark_ready_ephemerons()
static void mark_ready_ephemerons(GCTYPE *gc)
{
GC_Ephemeron *waiting = NULL, *next, *eph;
for (eph = GC->ephemerons; eph; eph = next) {
for (eph = gc->ephemerons; eph; eph = next) {
next = eph->next;
if (is_marked(eph->key)) {
if (is_marked(gc, eph->key)) {
gcMARK(eph->val);
GC->num_last_seen_ephemerons++;
gc->num_last_seen_ephemerons++;
} else {
eph->next = waiting;
waiting = eph;
}
}
GC->ephemerons = waiting;
gc->ephemerons = waiting;
}
static void zero_remaining_ephemerons()
static void zero_remaining_ephemerons(GCTYPE *gc)
{
GC_Ephemeron *eph;
/* After unordered finalization, any remaining ephemerons
should be zeroed. */
for (eph = GC->ephemerons; eph; eph = eph->next) {
for (eph = gc->ephemerons; eph; eph = eph->next) {
eph->key = NULL;
eph->val = NULL;
}