/* Dumps data from all threads into an array of per-thread data. */
static MVMObject * dump_data(MVMThreadContext *tc) {
MVMObject *threads_array;
ProfDumpStrs pds;
/* We'll allocate the data in gen2, but as we want to keep it, but to be
* sure we don't trigger a GC run. */
MVM_gc_allocate_gen2_default_set(tc);
/* Some string constants to re-use. */
pds.total_time = str(tc, "total_time");
pds.call_graph = str(tc, "call_graph");
pds.name = str(tc, "name");
pds.id = str(tc, "id");
pds.file = str(tc, "file");
pds.line = str(tc, "line");
pds.entries = str(tc, "entries");
pds.spesh_entries = str(tc, "spesh_entries");
pds.jit_entries = str(tc, "jit_entries");
pds.inlined_entries = str(tc, "inlined_entries");
pds.inclusive_time = str(tc, "inclusive_time");
pds.exclusive_time = str(tc, "exclusive_time");
pds.callees = str(tc, "callees");
pds.allocations = str(tc, "allocations");
pds.type = str(tc, "type");
pds.count = str(tc, "count");
pds.spesh = str(tc, "spesh");
pds.jit = str(tc, "jit");
pds.gcs = str(tc, "gcs");
pds.time = str(tc, "time");
pds.full = str(tc, "full");
pds.cleared_bytes = str(tc, "cleared_bytes");
pds.retained_bytes = str(tc, "retained_bytes");
pds.promoted_bytes = str(tc, "promoted_bytes");
pds.gen2_roots = str(tc, "gen2_roots");
pds.osr = str(tc, "osr");
pds.deopt_one = str(tc, "deopt_one");
pds.deopt_all = str(tc, "deopt_all");
pds.spesh_time = str(tc, "spesh_time");
pds.native_lib = str(tc, "native library");
/* Build up threads array. */
/* XXX Only main thread for now. */
threads_array = new_array(tc);
if (tc->prof_data)
MVM_repr_push_o(tc, threads_array, dump_thread_data(tc, &pds, tc->prof_data));
/* Switch back to default allocation and return result; */
MVM_gc_allocate_gen2_default_clear(tc);
return threads_array;
}
/* Creates a new serialization context with the specified handle. If any
* compilation units are waiting for an SC with this handle, removes it from
* their to-resolve list after installing itself in the appropriate slot. */
MVMObject * MVM_sc_create(MVMThreadContext *tc, MVMString *handle) {
MVMSerializationContext *sc;
MVMSerializationContextBody *scb;
/* Allocate. */
MVMROOT(tc, handle, {
sc = (MVMSerializationContext *)REPR(tc->instance->SCRef)->allocate(tc, STABLE(tc->instance->SCRef));
MVMROOT(tc, sc, {
/* Add to weak lookup hash. */
uv_mutex_lock(&tc->instance->mutex_sc_weakhash);
MVM_string_flatten(tc, handle);
MVM_HASH_GET(tc, tc->instance->sc_weakhash, handle, scb);
if (!scb) {
sc->body = scb = calloc(1, sizeof(MVMSerializationContextBody));
MVM_ASSIGN_REF(tc, (MVMObject *)sc, scb->handle, handle);
MVM_HASH_BIND(tc, tc->instance->sc_weakhash, handle, scb);
/* Calling repr_init will allocate, BUT if it does so, and we
* get unlucky, the GC will try to acquire mutex_sc_weakhash.
* This deadlocks. Thus, we force allocation in gen2, which
* can never trigger GC. Note that releasing the mutex early
* is not a good way to fix this, as it leaves a race to
* test/set scb->sc (between the line doing it in this block,
* and in the else clauses beneath it). */
MVM_gc_allocate_gen2_default_set(tc);
MVM_repr_init(tc, (MVMObject *)sc);
MVM_gc_allocate_gen2_default_clear(tc);
scb->sc = sc;
}
else if (scb->sc) {
/* we lost a race to create it! */
sc = scb->sc;
}
else {
scb->sc = sc;
sc->body = scb;
MVM_ASSIGN_REF(tc, sc, scb->handle, handle);
MVM_repr_init(tc, (MVMObject *)sc);
}
uv_mutex_unlock(&tc->instance->mutex_sc_weakhash);
});
});
MVMObject * collection_to_mvm_objects(MVMThreadContext *tc, MVMHeapSnapshotCollection *col) {
MVMObject *results;
/* Allocate in gen2, so as not to trigger GC. */
MVM_gc_allocate_gen2_default_set(tc);
/* Top-level results is a hash. */
results = MVM_repr_alloc_init(tc, MVM_hll_current(tc)->slurpy_hash_type);
MVM_repr_bind_key_o(tc, results, vmstr(tc, "strings"),
string_heap_array(tc, col));
MVM_repr_bind_key_o(tc, results, vmstr(tc, "types"),
types_str(tc, col));
MVM_repr_bind_key_o(tc, results, vmstr(tc, "static_frames"),
static_frames_str(tc, col));
MVM_repr_bind_key_o(tc, results, vmstr(tc, "snapshots"),
snapshots_to_mvm_objects(tc, col));
/* Switch off gen2 allocations now we're done. */
MVM_gc_allocate_gen2_default_clear(tc);
return results;
}
/* Create a new instance of the VM. */
MVMInstance * MVM_vm_create_instance(void) {
MVMInstance *instance;
char *spesh_log, *spesh_disable, *spesh_inline_disable, *spesh_osr_disable;
char *jit_log, *jit_disable, *jit_bytecode_dir;
char *dynvar_log;
int init_stat;
/* Set up instance data structure. */
instance = calloc(1, sizeof(MVMInstance));
/* Create the main thread's ThreadContext and stash it. */
instance->main_thread = MVM_tc_create(instance);
instance->main_thread->thread_id = 1;
/* No user threads when we start, and next thread to be created gets ID 2
* (the main thread got ID 1). */
instance->num_user_threads = 0;
MVM_store(&instance->next_user_thread_id, 2);
/* Set up the permanent roots storage. */
instance->num_permroots = 0;
instance->alloc_permroots = 16;
instance->permroots = MVM_malloc(sizeof(MVMCollectable **) * instance->alloc_permroots);
init_mutex(instance->mutex_permroots, "permanent roots");
/* Create fixed size allocator. */
instance->fsa = MVM_fixed_size_create(instance->main_thread);
/* Set up REPR registry mutex. */
init_mutex(instance->mutex_repr_registry, "REPR registry");
/* Set up HLL config mutex. */
init_mutex(instance->mutex_hllconfigs, "hll configs");
/* Set up DLL registry mutex. */
init_mutex(instance->mutex_dll_registry, "REPR registry");
/* Set up extension registry mutex. */
init_mutex(instance->mutex_ext_registry, "extension registry");
/* Set up extension op registry mutex. */
init_mutex(instance->mutex_extop_registry, "extension op registry");
/* Set up weak reference hash mutex. */
init_mutex(instance->mutex_sc_weakhash, "sc weakhash");
/* Set up loaded compunits hash mutex. */
init_mutex(instance->mutex_loaded_compunits, "loaded compunits");
/* Set up container registry mutex. */
init_mutex(instance->mutex_container_registry, "container registry");
/* Set up persistent object ID hash mutex. */
init_mutex(instance->mutex_object_ids, "object ID hash");
/* Allocate all things during following setup steps directly in gen2, as
* they will have program lifetime. */
MVM_gc_allocate_gen2_default_set(instance->main_thread);
init_mutex(instance->mutex_int_const_cache, "int constant cache");
instance->int_const_cache = calloc(1, sizeof(MVMIntConstCache));
/* Bootstrap 6model. It is assumed the GC will not be called during this. */
MVM_6model_bootstrap(instance->main_thread);
/* Fix up main thread's usecapture. */
instance->main_thread->cur_usecapture = MVM_repr_alloc_init(instance->main_thread, instance->CallCapture);
/* Initialize event loop thread starting mutex. */
init_mutex(instance->mutex_event_loop_start, "event loop thread start");
/* Create main thread object, and also make it the start of the all threads
* linked list. */
MVM_store(&instance->threads,
(instance->main_thread->thread_obj = (MVMThread *)
REPR(instance->boot_types.BOOTThread)->allocate(
instance->main_thread, STABLE(instance->boot_types.BOOTThread))));
instance->threads->body.stage = MVM_thread_stage_started;
instance->threads->body.tc = instance->main_thread;
instance->threads->body.thread_id = uv_thread_self();
/* Create compiler registry */
instance->compiler_registry = MVM_repr_alloc_init(instance->main_thread, instance->boot_types.BOOTHash);
/* Set up compiler registr mutex. */
init_mutex(instance->mutex_compiler_registry, "compiler registry");
/* Create hll symbol tables */
instance->hll_syms = MVM_repr_alloc_init(instance->main_thread, instance->boot_types.BOOTHash);
/* Set up hll symbol tables mutex. */
init_mutex(instance->mutex_hll_syms, "hll syms");
/* Initialize string cclass handling. */
MVM_string_cclass_init(instance->main_thread);
/* Create callsite intern pool. */
instance->callsite_interns = calloc(1, sizeof(MVMCallsiteInterns));
init_mutex(instance->mutex_callsite_interns, "callsite interns");
/* Allocate int to str cache. */
instance->int_to_str_cache = calloc(MVM_INT_TO_STR_CACHE_SIZE, sizeof(MVMString *));
/* Mutex for spesh installations, and check if we've a file we
* should log specializations to. */
init_mutex(instance->mutex_spesh_install, "spesh installations");
spesh_log = getenv("MVM_SPESH_LOG");
if (spesh_log && strlen(spesh_log))
instance->spesh_log_fh = fopen(spesh_log, "w");
spesh_disable = getenv("MVM_SPESH_DISABLE");
if (!spesh_disable || strlen(spesh_disable) == 0) {
instance->spesh_enabled = 1;
spesh_inline_disable = getenv("MVM_SPESH_INLINE_DISABLE");
if (!spesh_inline_disable || strlen(spesh_inline_disable) == 0)
instance->spesh_inline_enabled = 1;
spesh_osr_disable = getenv("MVM_SPESH_OSR_DISABLE");
if (!spesh_osr_disable || strlen(spesh_osr_disable) == 0)
instance->spesh_osr_enabled = 1;
}
jit_disable = getenv("MVM_JIT_DISABLE");
if (!jit_disable || strlen(jit_disable) == 0)
instance->jit_enabled = 1;
jit_log = getenv("MVM_JIT_LOG");
if (jit_log && strlen(jit_log))
instance->jit_log_fh = fopen(jit_log, "w");
jit_bytecode_dir = getenv("MVM_JIT_BYTECODE_DIR");
if (jit_bytecode_dir && strlen(jit_bytecode_dir))
instance->jit_bytecode_dir = jit_bytecode_dir;
dynvar_log = getenv("MVM_DYNVAR_LOG");
if (dynvar_log && strlen(dynvar_log))
instance->dynvar_log_fh = fopen(dynvar_log, "w");
else
instance->dynvar_log_fh = NULL;
/* Create std[in/out/err]. */
setup_std_handles(instance->main_thread);
/* Current instrumentation level starts at 1; used to trigger all frames
* to be verified before their first run. */
instance->instrumentation_level = 1;
/* Back to nursery allocation, now we're set up. */
MVM_gc_allocate_gen2_default_clear(instance->main_thread);
return instance;
}
/* Create a new instance of the VM. */
MVMInstance * MVM_vm_create_instance(void) {
MVMInstance *instance;
char *spesh_log, *spesh_nodelay, *spesh_disable, *spesh_inline_disable, *spesh_osr_disable;
char *jit_log, *jit_disable, *jit_bytecode_dir;
char *dynvar_log;
int init_stat;
/* Set up instance data structure. */
instance = MVM_calloc(1, sizeof(MVMInstance));
/* Create the main thread's ThreadContext and stash it. */
instance->main_thread = MVM_tc_create(instance);
instance->main_thread->thread_id = 1;
/* No user threads when we start, and next thread to be created gets ID 2
* (the main thread got ID 1). */
instance->num_user_threads = 0;
MVM_store(&instance->next_user_thread_id, 2);
/* Set up the permanent roots storage. */
instance->num_permroots = 0;
instance->alloc_permroots = 16;
instance->permroots = MVM_malloc(sizeof(MVMCollectable **) * instance->alloc_permroots);
instance->permroot_descriptions = MVM_malloc(sizeof(char *) * instance->alloc_permroots);
init_mutex(instance->mutex_permroots, "permanent roots");
/* Create fixed size allocator. */
instance->fsa = MVM_fixed_size_create(instance->main_thread);
/* Set up REPR registry mutex. */
init_mutex(instance->mutex_repr_registry, "REPR registry");
/* Set up HLL config mutex. */
init_mutex(instance->mutex_hllconfigs, "hll configs");
/* Set up DLL registry mutex. */
init_mutex(instance->mutex_dll_registry, "REPR registry");
/* Set up extension registry mutex. */
init_mutex(instance->mutex_ext_registry, "extension registry");
/* Set up extension op registry mutex. */
init_mutex(instance->mutex_extop_registry, "extension op registry");
/* Set up weak reference hash mutex. */
init_mutex(instance->mutex_sc_weakhash, "sc weakhash");
/* Set up loaded compunits hash mutex. */
init_mutex(instance->mutex_loaded_compunits, "loaded compunits");
/* Set up container registry mutex. */
init_mutex(instance->mutex_container_registry, "container registry");
/* Set up persistent object ID hash mutex. */
init_mutex(instance->mutex_object_ids, "object ID hash");
/* Allocate all things during following setup steps directly in gen2, as
* they will have program lifetime. */
MVM_gc_allocate_gen2_default_set(instance->main_thread);
/* Set up integer constant and string cache. */
init_mutex(instance->mutex_int_const_cache, "int constant cache");
instance->int_const_cache = MVM_calloc(1, sizeof(MVMIntConstCache));
instance->int_to_str_cache = MVM_calloc(MVM_INT_TO_STR_CACHE_SIZE, sizeof(MVMString *));
/* Bootstrap 6model. It is assumed the GC will not be called during this. */
MVM_6model_bootstrap(instance->main_thread);
/* Fix up main thread's usecapture and last_payload. */
instance->main_thread->cur_usecapture = MVM_repr_alloc_init(instance->main_thread, instance->CallCapture);
instance->main_thread->last_payload = instance->VMNull;
/* Initialize event loop thread starting mutex. */
init_mutex(instance->mutex_event_loop_start, "event loop thread start");
/* Create main thread object, and also make it the start of the all threads
* linked list. */
MVM_store(&instance->threads,
(instance->main_thread->thread_obj = (MVMThread *)
REPR(instance->boot_types.BOOTThread)->allocate(
instance->main_thread, STABLE(instance->boot_types.BOOTThread))));
instance->threads->body.stage = MVM_thread_stage_started;
instance->threads->body.tc = instance->main_thread;
instance->threads->body.native_thread_id = MVM_platform_thread_id();
instance->threads->body.thread_id = instance->main_thread->thread_id;
/* Create compiler registry */
instance->compiler_registry = MVM_repr_alloc_init(instance->main_thread, instance->boot_types.BOOTHash);
/* Set up compiler registr mutex. */
init_mutex(instance->mutex_compiler_registry, "compiler registry");
/* Create hll symbol tables */
instance->hll_syms = MVM_repr_alloc_init(instance->main_thread, instance->boot_types.BOOTHash);
/* Set up hll symbol tables mutex. */
init_mutex(instance->mutex_hll_syms, "hll syms");
/* Initialize Unicode database */
MVM_unicode_init(instance->main_thread);
/* Initialize string cclass handling. */
MVM_string_cclass_init(instance->main_thread);
/* Create callsite intern pool. */
instance->callsite_interns = MVM_calloc(1, sizeof(MVMCallsiteInterns));
init_mutex(instance->mutex_callsite_interns, "callsite interns");
/* There's some callsites we statically use all over the place. Intern
* them, so that spesh may end up optimizing more "internal" stuff. */
MVM_callsite_initialize_common(instance->main_thread);
/* Multi-cache additions mutex. */
init_mutex(instance->mutex_multi_cache_add, "multi-cache addition");
/* Current instrumentation level starts at 1; used to trigger all frames
* to be verified before their first run. */
instance->instrumentation_level = 1;
/* Mutex for spesh installations, and check if we've a file we
* should log specializations to. */
init_mutex(instance->mutex_spesh_install, "spesh installations");
spesh_log = getenv("MVM_SPESH_LOG");
if (spesh_log && strlen(spesh_log))
instance->spesh_log_fh = fopen_perhaps_with_pid(spesh_log, "w");
spesh_disable = getenv("MVM_SPESH_DISABLE");
if (!spesh_disable || strlen(spesh_disable) == 0) {
instance->spesh_enabled = 1;
spesh_inline_disable = getenv("MVM_SPESH_INLINE_DISABLE");
if (!spesh_inline_disable || strlen(spesh_inline_disable) == 0)
instance->spesh_inline_enabled = 1;
spesh_osr_disable = getenv("MVM_SPESH_OSR_DISABLE");
if (!spesh_osr_disable || strlen(spesh_osr_disable) == 0)
instance->spesh_osr_enabled = 1;
}
/* Should we specialize without warm up delays? Used to find bugs in the
* specializer and JIT. */
spesh_nodelay = getenv("MVM_SPESH_NODELAY");
if (spesh_nodelay && strlen(spesh_nodelay)) {
instance->spesh_nodelay = 1;
}
/* JIT environment/logging setup. */
jit_disable = getenv("MVM_JIT_DISABLE");
if (!jit_disable || strlen(jit_disable) == 0)
instance->jit_enabled = 1;
jit_log = getenv("MVM_JIT_LOG");
if (jit_log && strlen(jit_log))
instance->jit_log_fh = fopen_perhaps_with_pid(jit_log, "w");
jit_bytecode_dir = getenv("MVM_JIT_BYTECODE_DIR");
if (jit_bytecode_dir && strlen(jit_bytecode_dir)) {
char *bytecode_map_name = MVM_malloc(strlen(jit_bytecode_dir) + strlen("/jit-map.txt") + 1);
sprintf(bytecode_map_name, "%s/jit-map.txt", jit_bytecode_dir);
instance->jit_bytecode_map = fopen(bytecode_map_name, "w");
instance->jit_bytecode_dir = jit_bytecode_dir;
MVM_free(bytecode_map_name);
}
instance->jit_seq_nr = 0;
/* Various kinds of debugging that can be enabled. */
dynvar_log = getenv("MVM_DYNVAR_LOG");
if (dynvar_log && strlen(dynvar_log)) {
instance->dynvar_log_fh = fopen_perhaps_with_pid(dynvar_log, "w");
fprintf(instance->dynvar_log_fh, "+ x 0 0 0 0 0 %llu\n", uv_hrtime());
fflush(instance->dynvar_log_fh);
instance->dynvar_log_lasttime = uv_hrtime();
}
else
instance->dynvar_log_fh = NULL;
instance->nfa_debug_enabled = getenv("MVM_NFA_DEB") ? 1 : 0;
if (getenv("MVM_CROSS_THREAD_WRITE_LOG")) {
instance->cross_thread_write_logging = 1;
instance->cross_thread_write_logging_include_locked =
getenv("MVM_CROSS_THREAD_WRITE_LOG_INCLUDE_LOCKED") ? 1 : 0;
instance->instrumentation_level++;
init_mutex(instance->mutex_cross_thread_write_logging,
"cross thread write logging output");
}
else {
instance->cross_thread_write_logging = 0;
}
/* Set up NFG state mutation mutex. */
instance->nfg = calloc(1, sizeof(MVMNFGState));
init_mutex(instance->nfg->update_mutex, "NFG update mutex");
/* Create std[in/out/err]. */
setup_std_handles(instance->main_thread);
/* Back to nursery allocation, now we're set up. */
MVM_gc_allocate_gen2_default_clear(instance->main_thread);
return instance;
}
MVMInstance * MVM_vm_create_instance(void) {
MVMInstance *instance;
int init_stat;
/* Set up instance data structure. */
instance = calloc(1, sizeof(MVMInstance));
/* Create the main thread's ThreadContext and stash it. */
instance->main_thread = MVM_tc_create(instance);
/* No user threads when we start, and next thread to be created gets ID 1
* (the main thread got ID 0). */
instance->num_user_threads = 0;
MVM_store(&instance->next_user_thread_id, 1);
/* Set up the permanent roots storage. */
instance->num_permroots = 0;
instance->alloc_permroots = 16;
instance->permroots = malloc(sizeof(MVMCollectable **) * instance->alloc_permroots);
init_mutex(instance->mutex_permroots, "permanent roots");
/* Set up REPR registry mutex. */
init_mutex(instance->mutex_repr_registry, "REPR registry");
/* Set up HLL config mutex. */
init_mutex(instance->mutex_hllconfigs, "hll configs");
/* Set up DLL registry mutex. */
init_mutex(instance->mutex_dll_registry, "REPR registry");
/* Set up extension registry mutex. */
init_mutex(instance->mutex_ext_registry, "extension registry");
/* Set up extension op registry mutex. */
init_mutex(instance->mutex_extop_registry, "extension op registry");
/* Set up weak reference hash mutex. */
init_mutex(instance->mutex_sc_weakhash, "sc weakhash");
/* Set up loaded compunits hash mutex. */
init_mutex(instance->mutex_loaded_compunits, "loaded compunits");
/* Set up container registry mutex. */
init_mutex(instance->mutex_container_registry, "container registry");
/* Allocate all things during following setup steps directly in gen2, as
* they will have program lifetime. */
MVM_gc_allocate_gen2_default_set(instance->main_thread);
/* Bootstrap 6model. It is assumed the GC will not be called during this. */
MVM_6model_bootstrap(instance->main_thread);
/* Fix up main thread's usecapture. */
instance->main_thread->cur_usecapture = MVM_repr_alloc_init(instance->main_thread, instance->CallCapture);
/* get libuv default event loop. */
instance->default_loop = instance->main_thread->loop;
/* Create main thread object, and also make it the start of the all threads
* linked list. */
MVM_store(&instance->threads,
(instance->main_thread->thread_obj = (MVMThread *)
REPR(instance->boot_types.BOOTThread)->allocate(
instance->main_thread, STABLE(instance->boot_types.BOOTThread))));
instance->threads->body.stage = MVM_thread_stage_started;
instance->threads->body.tc = instance->main_thread;
/* Create compiler registry */
instance->compiler_registry = MVM_repr_alloc_init(instance->main_thread, instance->boot_types.BOOTHash);
/* Set up compiler registr mutex. */
init_mutex(instance->mutex_compiler_registry, "compiler registry");
/* Create hll symbol tables */
instance->hll_syms = MVM_repr_alloc_init(instance->main_thread, instance->boot_types.BOOTHash);
/* Set up hll symbol tables mutex. */
init_mutex(instance->mutex_hll_syms, "hll syms");
/* Initialize string cclass handling. */
MVM_string_cclass_init(instance->main_thread);
/* Set up some string constants commonly used. */
string_consts(instance->main_thread);
/* Create std[in/out/err]. */
setup_std_handles(instance->main_thread);
/* Back to nursery allocation, now we're set up. */
MVM_gc_allocate_gen2_default_clear(instance->main_thread);
return instance;
}
