// set up the defaults; perform any necessary registration with the app_manager, etc...
void tier2_message::resolve_requester_and_receiver_issues(void)
{
assert(requester || m_receiver);
/*
Default: receiver == requester.
*/
if (!m_receiver)
{
assert(dynamic_cast<tier2_message_processor *>(requester));
m_receiver = requester;
assert(m_receiver);
}
if (!requester)
{
requester = m_receiver;
}
if (requester != m_receiver)
{
/*
Also register the thread interconnect so that we can re-use it
later on to send/receive additional messages across the same
interconnection.
The creation/registration is a side effect of the query:
*/
(void)requester->get_interthread_communicator(requester, m_receiver);
}
assert(!m_owner);
current_owner(requester);
}
inline static void BTC_register_thread(void *t, void *c)
{
NewGC *gc = GC_get_GC();
GC_Thread_Info *work;
work = ((Scheme_Thread *)t)->gc_info;
work->owner = current_owner(gc, (Scheme_Custodian *)c);
}
inline static void BTC_register_thread(void *t, void *c)
{
NewGC *gc = GC_get_GC();
GC_Thread_Info *work;
if (((Scheme_Object *)t)->type == scheme_thread_type)
work = ((Scheme_Thread *)t)->gc_info;
else
work = ((Scheme_Place *)t)->gc_info;
work->owner = current_owner(gc, (Scheme_Custodian *)c);
}
inline static void BTC_register_new_thread(void *t, void *c)
{
NewGC *gc = GC_get_GC();
GC_Thread_Info *work;
work = (GC_Thread_Info *)ofm_malloc(sizeof(GC_Thread_Info));
((Scheme_Thread *)t)->gc_info = work;
work->owner = current_owner(gc, (Scheme_Custodian *)c);
work->thread = t;
work->next = gc->thread_infos;
gc->thread_infos = work;
}
static void BTC_do_accounting(NewGC *gc)
{
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(gc, NULL)]->originator, *last, *parent;
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->master_page_btc_mark_checked = 0;
/* clear the memory use numbers out */
for(i = 1; i < table_size; i++)
if(owner_table[i]) {
owner_table[i]->memory_use = 0;
#ifdef MZ_USE_PLACES
if (MASTERGC && MASTERGC->major_places_gc)
owner_table[i]->master_memory_use = 0;
#endif
}
/* start with root: */
while (cur->parent && SCHEME_PTR1_VAL(cur->parent)) {
cur = SCHEME_PTR1_VAL(cur->parent);
}
/* walk forward for the order we want (blame parents instead of children) */
last = cur;
while(cur) {
int owner = custodian_to_owner_set(gc, cur);
uintptr_t save_count = gc->phantom_count;
gc->phantom_count = 0;
gc->current_mark_owner = owner;
GCDEBUG((DEBUGOUTF,"MARKING THREADS OF OWNER %i (CUST %p)\n", owner, cur));
gc->kill_propagation_loop = 0;
mark_threads(gc, owner);
mark_cust_boxes(gc, cur);
GCDEBUG((DEBUGOUTF, "Propagating accounting marks\n"));
propagate_accounting_marks(gc);
last = cur;
box = cur->global_next; cur = box ? SCHEME_PTR1_VAL(box) : NULL;
owner_table = gc->owner_table;
owner_table[owner]->memory_use = add_no_overflow(owner_table[owner]->memory_use,
gcBYTES_TO_WORDS(gc->phantom_count));
gc->phantom_count = save_count;
}
release_master_btc_mark(gc);
/* walk backward folding totals int parent */
cur = last;
while (cur) {
int owner = custodian_to_owner_set(gc, cur);
box = cur->parent; parent = box ? SCHEME_PTR1_VAL(box) : NULL;
if (parent) {
int powner = custodian_to_owner_set(gc, parent);
owner_table = gc->owner_table;
owner_table[powner]->memory_use = add_no_overflow(owner_table[powner]->memory_use,
owner_table[owner]->memory_use);
owner_table[powner]->master_memory_use += owner_table[owner]->master_memory_use;
}
box = cur->global_prev; cur = box ? SCHEME_PTR1_VAL(box) : NULL;
}
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(gc);
}
