/* Adds the set of permanently registered roots to a GC worklist. */
void MVM_gc_root_add_permanents_to_worklist(MVMThreadContext *tc, MVMGCWorklist *worklist, MVMHeapSnapshotState *snapshot) {
MVMuint32 i, num_roots;
MVMCollectable ***permroots;
num_roots = tc->instance->num_permroots;
permroots = tc->instance->permroots;
if (worklist) {
for (i = 0; i < num_roots; i++)
MVM_gc_worklist_add(tc, worklist, permroots[i]);
}
else {
char **permroot_descriptions = tc->instance->permroot_descriptions;
for (i = 0; i < num_roots; i++)
MVM_profile_heap_add_collectable_rel_const_cstr(tc, snapshot,
*(permroots[i]), permroot_descriptions[i]);
}
}
static void process_workitems(MVMThreadContext *tc, MVMHeapSnapshotState *ss) {
while (ss->num_workitems > 0) {
MVMHeapSnapshotWorkItem item = pop_workitem(tc, ss);
/* We take our own working copy of the collectable info, since the
* collectables array can grow and be reallocated. */
MVMHeapSnapshotCollectable col;
set_ref_from(tc, ss, item.col_idx);
col = ss->hs->collectables[item.col_idx];
col.kind = item.kind;
switch (item.kind) {
case MVM_SNAPSHOT_COL_KIND_OBJECT:
case MVM_SNAPSHOT_COL_KIND_TYPE_OBJECT:
process_object(tc, ss, &col, (MVMObject *)item.target);
break;
case MVM_SNAPSHOT_COL_KIND_STABLE: {
MVMuint16 i;
MVMSTable *st = (MVMSTable *)item.target;
process_collectable(tc, ss, &col, (MVMCollectable *)st);
set_type_index(tc, ss, &col, st);
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->method_cache, "Method cache");
for (i = 0; i < st->type_check_cache_length; i++)
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->type_check_cache[i], "Type cache entry");
if (st->container_spec && st->container_spec->gc_mark_data) {
st->container_spec->gc_mark_data(tc, st, ss->gcwl);
process_gc_worklist(tc, ss, "Container spec data item");
}
if (st->boolification_spec)
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->boolification_spec->method,
"Boolification method");
if (st->invocation_spec) {
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->invocation_spec->class_handle,
"Invocation spec class handle");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->invocation_spec->attr_name,
"Invocation spec attribute name");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->invocation_spec->invocation_handler,
"Invocation spec invocation handler");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->invocation_spec->md_class_handle,
"Invocation spec class handle (multi)");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->invocation_spec->md_cache_attr_name,
"Invocation spec cache attribute name (multi)");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->invocation_spec->md_valid_attr_name,
"Invocation spec valid attribute name (multi)");
}
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->WHO, "WHO");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->WHAT, "WHAT");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->HOW, "HOW");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->HOW_sc, "HOW serialization context");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->method_cache_sc,
"Method cache serialization context");
if (st->mode_flags & MVM_PARAMETRIC_TYPE) {
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->paramet.ric.parameterizer,
"Parametric type parameterizer");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->paramet.ric.lookup,
"Parametric type intern table");
}
else if (st->mode_flags & MVM_PARAMETERIZED_TYPE) {
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->paramet.erized.parametric_type,
"Parameterized type's parametric type");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)st->paramet.erized.parameters,
"Parameterized type's parameters");
}
if (st->REPR->gc_mark_repr_data) {
st->REPR->gc_mark_repr_data(tc, st, ss->gcwl);
process_gc_worklist(tc, ss, "REPR data item");
}
break;
}
case MVM_SNAPSHOT_COL_KIND_FRAME: {
MVMFrame *frame = (MVMFrame *)item.target;
col.collectable_size = sizeof(MVMFrame);
set_static_frame_index(tc, ss, &col, frame->static_info);
if (frame->caller && !MVM_FRAME_IS_ON_CALLSTACK(tc, frame))
add_reference_const_cstr(tc, ss, "Caller",
get_frame_idx(tc, ss, frame->caller));
if (frame->outer)
add_reference_const_cstr(tc, ss, "Outer",
get_frame_idx(tc, ss, frame->outer));
MVM_gc_root_add_frame_registers_to_worklist(tc, ss->gcwl, frame);
process_gc_worklist(tc, ss, "Register");
if (frame->work)
col.unmanaged_size += frame->allocd_work;
if (frame->env) {
MVMuint16 i, count;
MVMuint16 *type_map;
MVMuint16 name_count = frame->static_info->body.num_lexicals;
MVMLexicalRegistry **names = frame->static_info->body.lexical_names_list;
if (frame->spesh_cand && frame->spesh_log_idx == -1 && frame->spesh_cand->lexical_types) {
type_map = frame->spesh_cand->lexical_types;
count = frame->spesh_cand->num_lexicals;
}
else {
type_map = frame->static_info->body.lexical_types;
count = frame->static_info->body.num_lexicals;
}
for (i = 0; i < count; i++) {
if (type_map[i] == MVM_reg_str || type_map[i] == MVM_reg_obj) {
if (i < name_count)
MVM_profile_heap_add_collectable_rel_vm_str(tc, ss,
(MVMCollectable *)frame->env[i].o, names[i]->key);
else
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)frame->env[i].o, "Lexical (inlined)");
}
}
col.unmanaged_size += frame->allocd_env;
}
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)frame->code_ref, "Code reference");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)frame->static_info, "Static frame");
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)frame->dynlex_cache_name,
"Dynamic lexical cache name");
if (frame->special_return_data && frame->mark_special_return_data) {
frame->mark_special_return_data(tc, frame, ss->gcwl);
process_gc_worklist(tc, ss, "Special return data");
}
if (frame->continuation_tags) {
MVMContinuationTag *tag = frame->continuation_tags;
while (tag) {
MVM_profile_heap_add_collectable_rel_const_cstr(tc, ss,
(MVMCollectable *)tag->tag, "Continuation tag");
col.unmanaged_size += sizeof(MVMContinuationTag);
tag = tag->next;
}
}
break;
}
case MVM_SNAPSHOT_COL_KIND_PERM_ROOTS:
MVM_gc_root_add_permanents_to_worklist(tc, NULL, ss);
break;
case MVM_SNAPSHOT_COL_KIND_INSTANCE_ROOTS:
MVM_gc_root_add_instance_roots_to_worklist(tc, NULL, ss);
break;
case MVM_SNAPSHOT_COL_KIND_CSTACK_ROOTS:
MVM_gc_root_add_temps_to_worklist((MVMThreadContext *)item.target, NULL, ss);
break;
case MVM_SNAPSHOT_COL_KIND_THREAD_ROOTS: {
MVMThreadContext *thread_tc = (MVMThreadContext *)item.target;
MVM_gc_root_add_tc_roots_to_worklist(thread_tc, NULL, ss);
if (thread_tc->cur_frame && !MVM_FRAME_IS_ON_CALLSTACK(thread_tc, tc->cur_frame))
add_reference_const_cstr(tc, ss, "Current frame",
get_frame_idx(tc, ss, thread_tc->cur_frame));
break;
}
case MVM_SNAPSHOT_COL_KIND_ROOT: {
MVMThread *cur_thread;
add_reference_const_cstr(tc, ss, "Permanent Roots",
push_workitem(tc, ss, MVM_SNAPSHOT_COL_KIND_PERM_ROOTS, NULL));
add_reference_const_cstr(tc, ss, "VM Instance Roots",
push_workitem(tc, ss, MVM_SNAPSHOT_COL_KIND_INSTANCE_ROOTS, NULL));
cur_thread = tc->instance->threads;
while (cur_thread) {
if (cur_thread->body.tc) {
add_reference_const_cstr(tc, ss, "C Stack Roots",
push_workitem(tc, ss,
MVM_SNAPSHOT_COL_KIND_CSTACK_ROOTS,
cur_thread->body.tc));
add_reference_const_cstr(tc, ss, "Thread Roots",
push_workitem(tc, ss,
MVM_SNAPSHOT_COL_KIND_THREAD_ROOTS,
cur_thread->body.tc));
add_reference_const_cstr(tc, ss, "Inter-generational Roots",
push_workitem(tc, ss,
MVM_SNAPSHOT_COL_KIND_INTERGEN_ROOTS,
cur_thread->body.tc));
add_reference_const_cstr(tc, ss, "Thread Call Stack Roots",
push_workitem(tc, ss,
MVM_SNAPSHOT_COL_KIND_CALLSTACK_ROOTS,
cur_thread->body.tc));
}
cur_thread = cur_thread->body.next;
}
break;
}
case MVM_SNAPSHOT_COL_KIND_INTERGEN_ROOTS: {
MVMThreadContext *thread_tc = (MVMThreadContext *)item.target;
MVM_gc_root_add_gen2s_to_snapshot(thread_tc, ss);
break;
}
case MVM_SNAPSHOT_COL_KIND_CALLSTACK_ROOTS: {
MVMThreadContext *thread_tc = (MVMThreadContext *)item.target;
if (thread_tc->cur_frame && MVM_FRAME_IS_ON_CALLSTACK(tc, thread_tc->cur_frame)) {
MVMFrame *cur_frame = thread_tc->cur_frame;
MVMint32 idx = 0;
while (cur_frame && MVM_FRAME_IS_ON_CALLSTACK(tc, cur_frame)) {
add_reference_idx(tc, ss, idx,
push_workitem(tc, ss, MVM_SNAPSHOT_COL_KIND_FRAME,
(MVMCollectable *)cur_frame));
idx++;
cur_frame = cur_frame->caller;
}
}
break;
}
default:
MVM_panic(1, "Unknown heap snapshot worklist item kind %d", item.kind);
}
/* Store updated collectable info into array. Note that num_refs was
* updated "at a distance". */
col.num_refs = ss->hs->collectables[item.col_idx].num_refs;
ss->hs->collectables[item.col_idx] = col;
}
}
