From fe33bed50573fa548e9daf00b90e016c401b6440 Mon Sep 17 00:00:00 2001 From: Zoltan Varga Date: Mon, 22 Feb 2021 14:02:32 -0500 Subject: [PATCH] Transition JIT memory management from domains to memory managers (#48483) * [jit] Add a MonoJitMemoryManager structure, which is the same as the MonoJitDomainInfo structure, but owned by a MonoMemoryManager instead of a domain. * Move static_rgctx_trampoline_hash to MonoJitMemoryManager. * Move jump_target_hash to MonoJitMemoryManager. * Move jump_trampoline_hash to MonoJitMemoryManager. * Move jit_trampoline_hash to MonoJitMemoryManager. * Move delegate_trampoline_hash to MonoJitMemoryManager. * Move method_code_hash to MonoJitMemoryManager. * Move more fields to MonoJitMemoryManager. * Move llvm data to MonoJitMemoryManager. * Move arch_seq_points field to MonoJitMemoryManager. * Remove unused fields from MonoJitDomainInfo. * Use the default alc memory manager only for now. * Remove MonoJitDomainInfo which is now unused. --- src/mono/mono/metadata/domain-internals.h | 13 --- src/mono/mono/metadata/domain.c | 19 ---- src/mono/mono/metadata/loader-internals.h | 3 + src/mono/mono/metadata/memory-manager.c | 6 ++ src/mono/mono/metadata/object-internals.h | 2 + src/mono/mono/mini/aot-runtime.c | 28 +++--- src/mono/mono/mini/debugger-agent-stubs.c | 3 +- src/mono/mono/mini/debugger-agent.c | 48 +++++----- src/mono/mono/mini/debugger-agent.h | 4 +- src/mono/mono/mini/debugger-engine.c | 8 +- src/mono/mono/mini/driver.c | 12 +-- src/mono/mono/mini/interp/interp.c | 94 +++++++++--------- src/mono/mono/mini/interp/transform.c | 8 +- src/mono/mono/mini/llvm-jit.cpp | 22 ++--- src/mono/mono/mini/method-to-ir.c | 16 ++-- src/mono/mono/mini/mini-amd64.c | 23 +++-- src/mono/mono/mini/mini-arm.c | 19 ++-- src/mono/mono/mini/mini-arm64.c | 19 ++-- src/mono/mono/mini/mini-generic-sharing.c | 69 ++++++++------ src/mono/mono/mini/mini-llvm.c | 59 ++++++------ src/mono/mono/mini/mini-llvm.h | 3 +- src/mono/mono/mini/mini-runtime.c | 152 +++++++++++++++++------------- src/mono/mono/mini/mini-runtime.h | 41 ++++++-- src/mono/mono/mini/mini-s390x.c | 17 ++-- src/mono/mono/mini/mini-trampolines.c | 95 ++++++++++--------- src/mono/mono/mini/mini.c | 47 ++++----- src/mono/mono/mini/mini.h | 1 + src/mono/mono/mini/seq-points.c | 24 +++-- 28 files changed, 455 insertions(+), 400 deletions(-) diff --git a/src/mono/mono/metadata/domain-internals.h b/src/mono/mono/metadata/domain-internals.h index ebc1026..a483c5f 100644 --- a/src/mono/mono/metadata/domain-internals.h +++ b/src/mono/mono/metadata/domain-internals.h @@ -353,9 +353,6 @@ struct _MonoDomain { GHashTable *generic_virtual_cases; - /* Information maintained by the JIT engine */ - gpointer runtime_info; - /* Contains the compiled runtime invoke wrapper used by finalizers */ gpointer finalize_runtime_invoke; @@ -413,16 +410,6 @@ mono_install_runtime_load (MonoLoadFunc func); MonoDomain* mono_runtime_load (const char *filename, const char *runtime_version); -typedef void (*MonoCreateDomainFunc) (MonoDomain *domain); - -void -mono_install_create_domain_hook (MonoCreateDomainFunc func); - -typedef void (*MonoFreeDomainFunc) (MonoDomain *domain); - -void -mono_install_free_domain_hook (MonoFreeDomainFunc func); - void mono_runtime_quit_internal (void); diff --git a/src/mono/mono/metadata/domain.c b/src/mono/mono/metadata/domain.c index 0e53965..c14d8fe 100644 --- a/src/mono/mono/metadata/domain.c +++ b/src/mono/mono/metadata/domain.c @@ -112,10 +112,6 @@ static const MonoRuntimeInfo supported_runtimes[] = { /* The stable runtime version */ #define DEFAULT_RUNTIME_VERSION "v4.0.30319" -/* Callbacks installed by the JIT */ -static MonoCreateDomainFunc create_domain_hook; -static MonoFreeDomainFunc free_domain_hook; - static GSList* get_runtimes_from_exe (const char *exe_file, MonoImage **exe_image); @@ -208,18 +204,6 @@ lock_free_mempool_alloc0 (LockFreeMempool *mp, guint size) return res; } -void -mono_install_create_domain_hook (MonoCreateDomainFunc func) -{ - create_domain_hook = func; -} - -void -mono_install_free_domain_hook (MonoFreeDomainFunc func) -{ - free_domain_hook = func; -} - gboolean mono_string_equal_internal (MonoString *s1, MonoString *s2) { @@ -451,9 +435,6 @@ mono_domain_create (void) mono_alc_create_default (domain); - if (create_domain_hook) - create_domain_hook (domain); - MONO_PROFILER_RAISE (domain_loaded, (domain)); return domain; diff --git a/src/mono/mono/metadata/loader-internals.h b/src/mono/mono/metadata/loader-internals.h index 668a2cb..9ddac52 100644 --- a/src/mono/mono/metadata/loader-internals.h +++ b/src/mono/mono/metadata/loader-internals.h @@ -96,6 +96,9 @@ struct _MonoMemoryManager { /* Information maintained by mono-debug.c */ gpointer debug_info; + /* Information maintained by the execution engine */ + gpointer runtime_info; + // !!! REGISTERED AS GC ROOTS !!! // Hashtables for Reflection handles MonoGHashTable *type_hash; diff --git a/src/mono/mono/metadata/memory-manager.c b/src/mono/mono/metadata/memory-manager.c index 65955cb..ca7022f 100644 --- a/src/mono/mono/metadata/memory-manager.c +++ b/src/mono/mono/metadata/memory-manager.c @@ -21,6 +21,9 @@ memory_manager_init (MonoMemoryManager *memory_manager, MonoDomain *domain, gboo memory_manager->type_hash = mono_g_hash_table_new_type_internal ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Reflection Type Table"); memory_manager->refobject_hash = mono_conc_g_hash_table_new_type (mono_reflected_hash, mono_reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Reflection Object Table"); memory_manager->type_init_exception_hash = mono_g_hash_table_new_type_internal (mono_aligned_addr_hash, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Type Initialization Exception Table"); + + if (mono_get_runtime_callbacks ()->init_mem_manager) + mono_get_runtime_callbacks ()->init_mem_manager (memory_manager); } MonoSingletonMemoryManager * @@ -77,6 +80,9 @@ memory_manager_delete (MonoMemoryManager *memory_manager, gboolean debug_unload) { // Scan here to assert no lingering references in vtables? + if (mono_get_runtime_callbacks ()->free_mem_manager) + mono_get_runtime_callbacks ()->free_mem_manager (memory_manager); + if (memory_manager->debug_info) { mono_mem_manager_free_debug_info (memory_manager); memory_manager->debug_info = NULL; diff --git a/src/mono/mono/metadata/object-internals.h b/src/mono/mono/metadata/object-internals.h index c603aba..d484b706 100644 --- a/src/mono/mono/metadata/object-internals.h +++ b/src/mono/mono/metadata/object-internals.h @@ -637,6 +637,8 @@ typedef struct { GHashTable *(*get_weak_field_indexes) (MonoImage *image); void (*install_state_summarizer) (void); gboolean (*is_interpreter_enabled) (void); + void (*init_mem_manager)(MonoMemoryManager*); + void (*free_mem_manager)(MonoMemoryManager*); #ifdef ENABLE_METADATA_UPDATE void (*metadata_update_init) (MonoError *error); void (*metadata_update_published) (MonoDomain *domain, MonoAssemblyLoadContext *alc, uint32_t generation); diff --git a/src/mono/mono/mini/aot-runtime.c b/src/mono/mono/mini/aot-runtime.c index a9af4a1..7c96b41 100644 --- a/src/mono/mono/mini/aot-runtime.c +++ b/src/mono/mono/mini/aot-runtime.c @@ -3233,13 +3233,16 @@ decode_exception_debug_info (MonoAotModule *amodule, MonoDomain *domain, p += mono_seq_point_info_read (&seq_points, p, FALSE); - mono_domain_lock (domain); + // FIXME: Call a function in seq-points.c + // FIXME: + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + jit_mm_lock (jit_mm); /* This could be set already since this function can be called more than once for the same method */ - if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, method)) - g_hash_table_insert (domain_jit_info (domain)->seq_points, method, seq_points); + if (!g_hash_table_lookup (jit_mm->seq_points, method)) + g_hash_table_insert (jit_mm->seq_points, method, seq_points); else mono_seq_point_info_free (seq_points); - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); jinfo->seq_points = seq_points; } @@ -3994,18 +3997,19 @@ register_jump_target_got_slot (MonoDomain *domain, MonoMethod *method, gpointer * the addresses of the GOT slots pointing to a method, and patch * them after the method has been compiled. */ - MonoJitDomainInfo *info = domain_jit_info (domain); GSList *list; + MonoJitMemoryManager *jit_mm; MonoMethod *shared_method = mini_method_to_shared (method); method = shared_method ? shared_method : method; - - mono_domain_lock (domain); - if (!info->jump_target_got_slot_hash) - info->jump_target_got_slot_hash = g_hash_table_new (NULL, NULL); - list = (GSList *)g_hash_table_lookup (info->jump_target_got_slot_hash, method); + + jit_mm = jit_mm_for_method (method); + jit_mm_lock (jit_mm); + if (!jit_mm->jump_target_got_slot_hash) + jit_mm->jump_target_got_slot_hash = g_hash_table_new (NULL, NULL); + list = (GSList *)g_hash_table_lookup (jit_mm->jump_target_got_slot_hash, method); list = g_slist_prepend (list, got_slot); - g_hash_table_insert (info->jump_target_got_slot_hash, method, list); - mono_domain_unlock (domain); + g_hash_table_insert (jit_mm->jump_target_got_slot_hash, method, list); + jit_mm_unlock (jit_mm); } /* diff --git a/src/mono/mono/mini/debugger-agent-stubs.c b/src/mono/mono/mini/debugger-agent-stubs.c index 98054f8..7746e3a 100644 --- a/src/mono/mono/mini/debugger-agent-stubs.c +++ b/src/mono/mono/mini/debugger-agent-stubs.c @@ -36,7 +36,7 @@ stub_debugger_agent_single_step_event (void *sigctx) } static void -stub_debugger_agent_free_domain_info (MonoDomain *domain) +stub_debugger_agent_free_mem_manager (gpointer mem_manager) { } @@ -109,7 +109,6 @@ mono_debugger_agent_stub_init (void) cbs.single_step_event = stub_debugger_agent_single_step_event; cbs.single_step_from_context = stub_debugger_agent_single_step_from_context; cbs.breakpoint_from_context = stub_debugger_agent_breakpoint_from_context; - cbs.free_domain_info = stub_debugger_agent_free_domain_info; cbs.unhandled_exception = stub_debugger_agent_unhandled_exception; cbs.handle_exception = stub_debugger_agent_handle_exception; cbs.begin_exception_filter = stub_debugger_agent_begin_exception_filter; diff --git a/src/mono/mono/mini/debugger-agent.c b/src/mono/mono/mini/debugger-agent.c index 15915ac..ebc0b32 100644 --- a/src/mono/mono/mini/debugger-agent.c +++ b/src/mono/mono/mini/debugger-agent.c @@ -1761,15 +1761,20 @@ ids_cleanup (void) } static void -debugger_agent_free_domain_info (MonoDomain *domain) +debugger_agent_free_mem_manager (gpointer mem_manager) { - AgentDomainInfo *info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info; - int i, j; + MonoJitMemoryManager *jit_mm = (MonoJitMemoryManager*)mem_manager; + AgentDomainInfo *info = (AgentDomainInfo *)jit_mm->agent_info; + int i; GHashTableIter iter; GPtrArray *file_names; char *basename; GSList *l; + // FIXME: + if (mem_manager != get_default_jit_mm ()) + return; + if (info) { for (i = 0; i < ID_NUM; ++i) g_hash_table_destroy (info->val_to_id [i]); @@ -1797,8 +1802,9 @@ debugger_agent_free_domain_info (MonoDomain *domain) g_free (info); } - domain_jit_info (domain)->agent_info = NULL; + jit_mm->agent_info = NULL; +#if 0 /* Clear ids referencing structures in the domain */ dbg_lock (); for (i = 0; i < ID_NUM; ++i) { @@ -1811,17 +1817,15 @@ debugger_agent_free_domain_info (MonoDomain *domain) } } dbg_unlock (); - - mono_de_domain_remove (domain); +#endif } static AgentDomainInfo* -get_agent_domain_info (MonoDomain *domain) +get_agent_info (void) { AgentDomainInfo *info = NULL; - MonoJitDomainInfo *jit_info = domain_jit_info (domain); - - info = (AgentDomainInfo *)jit_info->agent_info; + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + info = (AgentDomainInfo *)jit_mm->agent_info; if (info) { mono_memory_read_barrier (); @@ -1836,7 +1840,7 @@ get_agent_domain_info (MonoDomain *domain) mono_memory_write_barrier (); - gpointer other_info = mono_atomic_cas_ptr (&jit_info->agent_info, info, NULL); + gpointer other_info = mono_atomic_cas_ptr (&jit_mm->agent_info, info, NULL); if (other_info != NULL) { g_hash_table_destroy (info->loaded_classes); @@ -1846,7 +1850,7 @@ get_agent_domain_info (MonoDomain *domain) g_free (info); } - return (AgentDomainInfo *)jit_info->agent_info; + return (AgentDomainInfo *)jit_mm->agent_info; } static int @@ -1858,7 +1862,7 @@ get_id (MonoDomain *domain, IdType type, gpointer val) if (val == NULL) return 0; - info = get_agent_domain_info (domain); + info = get_agent_info (); dbg_lock (); @@ -3012,7 +3016,7 @@ static void emit_appdomain_load (gpointer key, gpointer value, gpointer user_data) { process_profiler_event (EVENT_KIND_APPDOMAIN_CREATE, value); - g_hash_table_foreach (get_agent_domain_info ((MonoDomain *)value)->loaded_classes, emit_type_load, NULL); + g_hash_table_foreach (get_agent_info ()->loaded_classes, emit_type_load, NULL); } /* @@ -3846,10 +3850,9 @@ static void send_type_load (MonoClass *klass) { gboolean type_load = FALSE; - MonoDomain *domain = mono_domain_get (); AgentDomainInfo *info = NULL; - info = get_agent_domain_info (domain); + info = get_agent_info (); mono_loader_lock (); @@ -3875,7 +3878,7 @@ send_types_for_domain (MonoDomain *domain, void *user_data) MonoDomain* old_domain; AgentDomainInfo *info = NULL; - info = get_agent_domain_info (domain); + info = get_agent_info (); g_assert (info); old_domain = mono_domain_get (); @@ -5794,14 +5797,9 @@ type_comes_from_assembly (gpointer klass, gpointer also_klass, gpointer assembly static void clear_types_for_assembly (MonoAssembly *assembly) { - MonoDomain *domain = mono_domain_get (); AgentDomainInfo *info = NULL; - if (!domain || !domain_jit_info (domain)) - /* Can happen during shutdown */ - return; - - info = get_agent_domain_info (domain); + info = get_agent_info (); mono_loader_lock (); g_hash_table_foreach_remove (info->loaded_classes, type_comes_from_assembly, assembly); @@ -6336,7 +6334,7 @@ get_types_for_source_file (gpointer key, gpointer value, gpointer user_data) GetTypesForSourceFileArgs *ud = (GetTypesForSourceFileArgs*)user_data; MonoDomain *domain = (MonoDomain*)key; - AgentDomainInfo *info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info; + AgentDomainInfo *info = get_agent_info (); /* Update 'source_file_to_class' cache */ g_hash_table_iter_init (&iter, info->loaded_classes); @@ -9859,7 +9857,7 @@ mono_debugger_agent_init (void) cbs.single_step_event = debugger_agent_single_step_event; cbs.single_step_from_context = debugger_agent_single_step_from_context; cbs.breakpoint_from_context = debugger_agent_breakpoint_from_context; - cbs.free_domain_info = debugger_agent_free_domain_info; + cbs.free_mem_manager = debugger_agent_free_mem_manager; cbs.unhandled_exception = debugger_agent_unhandled_exception; cbs.handle_exception = debugger_agent_handle_exception; cbs.begin_exception_filter = debugger_agent_begin_exception_filter; diff --git a/src/mono/mono/mini/debugger-agent.h b/src/mono/mono/mini/debugger-agent.h index 9081890..5d2161b 100644 --- a/src/mono/mono/mini/debugger-agent.h +++ b/src/mono/mono/mini/debugger-agent.h @@ -8,7 +8,7 @@ #include "mini.h" #include -#define MONO_DBG_CALLBACKS_VERSION (3) +#define MONO_DBG_CALLBACKS_VERSION (4) // 2. debug_log parameters changed from MonoString* to MonoStringHandle // 3. debug_log parameters changed from MonoStringHandle back to MonoString* @@ -20,7 +20,7 @@ struct _MonoDebuggerCallbacks { void (*single_step_event) (void *sigctx); void (*single_step_from_context) (MonoContext *ctx); void (*breakpoint_from_context) (MonoContext *ctx); - void (*free_domain_info) (MonoDomain *domain); + void (*free_mem_manager) (gpointer mem_manager); void (*unhandled_exception) (MonoException *exc); void (*handle_exception) (MonoException *exc, MonoContext *throw_ctx, MonoContext *catch_ctx, StackFrameInfo *catch_frame); diff --git a/src/mono/mono/mini/debugger-engine.c b/src/mono/mono/mini/debugger-engine.c index 3be4afa..a48cd9e 100644 --- a/src/mono/mono/mini/debugger-engine.c +++ b/src/mono/mono/mini/debugger-engine.c @@ -373,8 +373,10 @@ collect_domain_bp (gpointer key, gpointer value, gpointer user_data) CollectDomainData *ud = (CollectDomainData*)user_data; MonoMethod *m; - mono_domain_lock (domain); - g_hash_table_iter_init (&iter, domain_jit_info (domain)->seq_points); + // FIXME: + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + jit_mm_lock (jit_mm); + g_hash_table_iter_init (&iter, jit_mm->seq_points); while (g_hash_table_iter_next (&iter, (void**)&m, (void**)&seq_points)) { if (bp_matches_method (ud->bp, m)) { /* Save the info locally to simplify the code inside the domain lock */ @@ -383,7 +385,7 @@ collect_domain_bp (gpointer key, gpointer value, gpointer user_data) g_ptr_array_add (ud->method_seq_points, seq_points); } } - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); } void diff --git a/src/mono/mono/mini/driver.c b/src/mono/mono/mini/driver.c index d9d493b..745970b 100644 --- a/src/mono/mono/mini/driver.c +++ b/src/mono/mono/mini/driver.c @@ -494,13 +494,11 @@ mini_regression_step (MonoImage *image, int verbose, int *total_run, int *total, comp_time = elapsed = 0.0; int local_skip_index = 0; - /* fixme: ugly hack - delete all previously compiled methods */ - if (domain_jit_info (domain)) { - g_hash_table_destroy (domain_jit_info (domain)->jit_trampoline_hash); - domain_jit_info (domain)->jit_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL); - mono_internal_hash_table_destroy (&(domain->jit_code_hash)); - mono_jit_code_hash_init (&(domain->jit_code_hash)); - } + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + g_hash_table_destroy (jit_mm->jit_trampoline_hash); + jit_mm->jit_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL); + mono_internal_hash_table_destroy (&(domain->jit_code_hash)); + mono_jit_code_hash_init (&(domain->jit_code_hash)); g_timer_start (timer); if (mini_stats_fd) diff --git a/src/mono/mono/mini/interp/interp.c b/src/mono/mono/mini/interp/interp.c index ffa1bcc..2e7bdc6 100644 --- a/src/mono/mono/mini/interp/interp.c +++ b/src/mono/mono/mini/interp/interp.c @@ -453,12 +453,12 @@ static InterpMethod* lookup_imethod (MonoDomain *domain, MonoMethod *method) { InterpMethod *imethod; - MonoJitDomainInfo *info; + MonoJitMemoryManager *jit_mm = jit_mm_for_method (method); + + jit_mm_lock (jit_mm); + imethod = (InterpMethod*)mono_internal_hash_table_lookup (&jit_mm->interp_code_hash, method); + jit_mm_unlock (jit_mm); - info = domain_jit_info (domain); - mono_domain_jit_code_hash_lock (domain); - imethod = (InterpMethod*)mono_internal_hash_table_lookup (&info->interp_code_hash, method); - mono_domain_jit_code_hash_unlock (domain); return imethod; } @@ -466,16 +466,15 @@ InterpMethod* mono_interp_get_imethod (MonoDomain *domain, MonoMethod *method, MonoError *error) { InterpMethod *imethod; - MonoJitDomainInfo *info; MonoMethodSignature *sig; + MonoJitMemoryManager *jit_mm = jit_mm_for_method (method); int i; error_init (error); - info = domain_jit_info (domain); - mono_domain_jit_code_hash_lock (domain); - imethod = (InterpMethod*)mono_internal_hash_table_lookup (&info->interp_code_hash, method); - mono_domain_jit_code_hash_unlock (domain); + jit_mm_lock (jit_mm); + imethod = (InterpMethod*)mono_internal_hash_table_lookup (&jit_mm->interp_code_hash, method); + jit_mm_unlock (jit_mm); if (imethod) return imethod; @@ -496,10 +495,10 @@ mono_interp_get_imethod (MonoDomain *domain, MonoMethod *method, MonoError *erro for (i = 0; i < sig->param_count; ++i) imethod->param_types [i] = mini_get_underlying_type (sig->params [i]); - mono_domain_jit_code_hash_lock (domain); - if (!mono_internal_hash_table_lookup (&info->interp_code_hash, method)) - mono_internal_hash_table_insert (&info->interp_code_hash, method, imethod); - mono_domain_jit_code_hash_unlock (domain); + jit_mm_lock (jit_mm); + if (!mono_internal_hash_table_lookup (&jit_mm->interp_code_hash, method)) + mono_internal_hash_table_insert (&jit_mm->interp_code_hash, method, imethod); + jit_mm_unlock (jit_mm); imethod->prof_flags = mono_profiler_get_call_instrumentation_flags (imethod->method); @@ -2651,14 +2650,13 @@ interp_entry_from_trampoline (gpointer ccontext_untyped, gpointer rmethod_untype static InterpMethod* lookup_method_pointer (gpointer addr) { - MonoDomain *domain = mono_domain_get (); - MonoJitDomainInfo *info = domain_jit_info (domain); InterpMethod *res = NULL; + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); - mono_domain_lock (domain); - if (info->interp_method_pointer_hash) - res = (InterpMethod*)g_hash_table_lookup (info->interp_method_pointer_hash, addr); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + if (jit_mm->interp_method_pointer_hash) + res = (InterpMethod*)g_hash_table_lookup (jit_mm->interp_method_pointer_hash, addr); + jit_mm_unlock (jit_mm); return res; } @@ -2689,7 +2687,6 @@ interp_create_method_pointer_llvmonly (MonoMethod *method, gboolean unbox, MonoE gpointer addr, entry_func, entry_wrapper; MonoMethodSignature *sig; MonoMethod *wrapper; - MonoJitDomainInfo *info; InterpMethod *imethod; imethod = mono_interp_get_imethod (domain, method, error); @@ -2747,12 +2744,13 @@ interp_create_method_pointer_llvmonly (MonoMethod *method, gboolean unbox, MonoE addr = mini_llvmonly_create_ftndesc (mono_domain_get (), entry_wrapper, entry_ftndesc); - info = domain_jit_info (domain); - mono_domain_lock (domain); - if (!info->interp_method_pointer_hash) - info->interp_method_pointer_hash = g_hash_table_new (NULL, NULL); - g_hash_table_insert (info->interp_method_pointer_hash, addr, imethod); - mono_domain_unlock (domain); + // FIXME: + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + jit_mm_lock (jit_mm); + if (!jit_mm->interp_method_pointer_hash) + jit_mm->interp_method_pointer_hash = g_hash_table_new (NULL, NULL); + g_hash_table_insert (jit_mm->interp_method_pointer_hash, addr, imethod); + jit_mm_unlock (jit_mm); mono_memory_barrier (); if (unbox) @@ -2774,7 +2772,6 @@ interp_create_method_pointer (MonoMethod *method, gboolean compile, MonoError *e { gpointer addr, entry_func, entry_wrapper = NULL; MonoDomain *domain = mono_domain_get (); - MonoJitDomainInfo *info; InterpMethod *imethod = mono_interp_get_imethod (domain, method, error); if (imethod->jit_entry) @@ -2906,12 +2903,12 @@ interp_create_method_pointer (MonoMethod *method, gboolean compile, MonoError *e addr = mono_create_ftnptr_arg_trampoline (ftndesc, entry_wrapper); - info = domain_jit_info (domain); - mono_domain_lock (domain); - if (!info->interp_method_pointer_hash) - info->interp_method_pointer_hash = g_hash_table_new (NULL, NULL); - g_hash_table_insert (info->interp_method_pointer_hash, addr, imethod); - mono_domain_unlock (domain); + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + jit_mm_lock (jit_mm); + if (!jit_mm->interp_method_pointer_hash) + jit_mm->interp_method_pointer_hash = g_hash_table_new (NULL, NULL); + g_hash_table_insert (jit_mm->interp_method_pointer_hash, addr, imethod); + jit_mm_unlock (jit_mm); mono_memory_barrier (); imethod->jit_entry = addr; @@ -2922,13 +2919,13 @@ interp_create_method_pointer (MonoMethod *method, gboolean compile, MonoError *e static void interp_free_method (MonoDomain *domain, MonoMethod *method) { - MonoJitDomainInfo *info = domain_jit_info (domain); + MonoJitMemoryManager *jit_mm = jit_mm_for_method (method); - mono_domain_jit_code_hash_lock (domain); + jit_mm_lock (jit_mm); /* InterpMethod is allocated in the domain mempool. We might haven't * allocated an InterpMethod for this instance yet */ - mono_internal_hash_table_remove (&info->interp_code_hash, method); - mono_domain_jit_code_hash_unlock (domain); + mono_internal_hash_table_remove (&jit_mm->interp_code_hash, method); + jit_mm_unlock (jit_mm); } #if COUNT_OPS @@ -7177,12 +7174,12 @@ static void interp_print_method_counts (void) { MonoDomain *domain = mono_get_root_domain (); - MonoJitDomainInfo *info = domain_jit_info (domain); + MonoJitMemoryManager *jit_mm = jit_mm_for_method (method); - mono_domain_jit_code_hash_lock (domain); - imethods = (InterpMethod**) malloc (info->interp_code_hash.num_entries * sizeof (InterpMethod*)); - mono_internal_hash_table_apply (&info->interp_code_hash, interp_add_imethod); - mono_domain_jit_code_hash_unlock (domain); + jit_mm_lock (jit_mm); + imethods = (InterpMethod**) malloc (jit_mm->interp_code_hash.num_entries * sizeof (InterpMethod*)); + mono_internal_hash_table_apply (&jit_mm->interp_code_hash, interp_add_imethod); + jit_mm_unlock (jit_mm); qsort (imethods, num_methods, sizeof (InterpMethod*), imethod_opcount_comparer); @@ -7285,10 +7282,13 @@ interp_invalidate_transformed (MonoDomain *domain) mono_stop_world (MONO_THREAD_INFO_FLAGS_NO_GC); metadata_update_prepare_to_invalidate (domain); #endif - MonoJitDomainInfo *info = domain_jit_info (domain); - mono_domain_jit_code_hash_lock (domain); - mono_internal_hash_table_apply (&info->interp_code_hash, invalidate_transform); - mono_domain_jit_code_hash_unlock (domain); + + // FIXME: Enumerate all memory managers + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + + jit_mm_lock (jit_mm); + mono_internal_hash_table_apply (&jit_mm->interp_code_hash, invalidate_transform); + jit_mm_unlock (jit_mm); if (need_stw_restart) mono_restart_world (MONO_THREAD_INFO_FLAGS_NO_GC); diff --git a/src/mono/mono/mini/interp/transform.c b/src/mono/mono/mini/interp/transform.c index b388abb..f49e6f6 100644 --- a/src/mono/mono/mini/interp/transform.c +++ b/src/mono/mono/mini/interp/transform.c @@ -8574,10 +8574,14 @@ mono_interp_transform_method (InterpMethod *imethod, ThreadContext *context, Mon g_printf ("Printing runtime stats at method: %s\n", mono_method_get_full_name (imethod->method)); mono_runtime_print_stats (); } - if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, imethod->method)) - g_hash_table_insert (domain_jit_info (domain)->seq_points, imethod->method, imethod->jinfo->seq_points); mono_domain_unlock (domain); + MonoJitMemoryManager *jit_mm = jit_mm_for_method (imethod->method); + jit_mm_lock (jit_mm); + if (!g_hash_table_lookup (jit_mm->seq_points, imethod->method)) + g_hash_table_insert (jit_mm->seq_points, imethod->method, imethod->jinfo->seq_points); + jit_mm_unlock (jit_mm); + // FIXME: Add a different callback ? MONO_PROFILER_RAISE (jit_done, (method, imethod->jinfo)); } diff --git a/src/mono/mono/mini/llvm-jit.cpp b/src/mono/mono/mini/llvm-jit.cpp index 1927586..9034799 100644 --- a/src/mono/mono/mini/llvm-jit.cpp +++ b/src/mono/mono/mini/llvm-jit.cpp @@ -92,10 +92,10 @@ alloc_code (LLVMValueRef function, int size) return (unsigned char *)mono_mem_manager_code_reserve (cfg->mem_manager, size); } -class MonoJitMemoryManager : public RTDyldMemoryManager +class MonoLLVMMemoryManager : public RTDyldMemoryManager { public: - ~MonoJitMemoryManager() override; + ~MonoLLVMMemoryManager() override; uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, @@ -113,12 +113,12 @@ private: SmallVector PendingCodeMem; }; -MonoJitMemoryManager::~MonoJitMemoryManager() +MonoLLVMMemoryManager::~MonoLLVMMemoryManager() { } uint8_t * -MonoJitMemoryManager::allocateDataSection(uintptr_t Size, +MonoLLVMMemoryManager::allocateDataSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName, @@ -138,7 +138,7 @@ MonoJitMemoryManager::allocateDataSection(uintptr_t Size, } uint8_t * -MonoJitMemoryManager::allocateCodeSection(uintptr_t Size, +MonoLLVMMemoryManager::allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName) @@ -149,7 +149,7 @@ MonoJitMemoryManager::allocateCodeSection(uintptr_t Size, } bool -MonoJitMemoryManager::finalizeMemory(std::string *ErrMsg) +MonoLLVMMemoryManager::finalizeMemory(std::string *ErrMsg) { for (sys::MemoryBlock &Block : PendingCodeMem) { #if LLVM_API_VERSION >= 900 @@ -197,7 +197,7 @@ init_function_pass_manager (legacy::FunctionPassManager &fpm) #if LLVM_API_VERSION >= 900 struct MonoLLVMJIT { - std::shared_ptr mmgr; + std::shared_ptr mmgr; ExecutionSession execution_session; std::map> resolvers; TargetMachine *target_machine; @@ -207,7 +207,7 @@ struct MonoLLVMJIT { legacy::FunctionPassManager fpm; MonoLLVMJIT (TargetMachine *tm, Module *pgo_module) - : mmgr (std::make_shared()) + : mmgr (std::make_shared()) , target_machine (tm) , object_layer ( AcknowledgeORCv1Deprecation, execution_session, @@ -331,7 +331,7 @@ public: typedef IRCompileLayer CompileLayerT; typedef CompileLayerT::ModuleHandleT ModuleHandleT; - MonoLLVMJIT (TargetMachine *TM, MonoJitMemoryManager *mm) + MonoLLVMJIT (TargetMachine *TM, MonoLLVMMemoryManager *mm) : TM(TM), ObjectLayer([=] { return std::shared_ptr (mm); }), CompileLayer (ObjectLayer, SimpleCompiler (*TM)), modules(), @@ -432,12 +432,12 @@ private: legacy::FunctionPassManager fpm; }; -static MonoJitMemoryManager *mono_mm; +static MonoLLVMMemoryManager *mono_mm; static MonoLLVMJIT * make_mono_llvm_jit (TargetMachine *target_machine, llvm::Module *) { - mono_mm = new MonoJitMemoryManager (); + mono_mm = new MonoLLVMMemoryManager (); return new MonoLLVMJIT(target_machine, mono_mm); } diff --git a/src/mono/mono/mini/method-to-ir.c b/src/mono/mono/mini/method-to-ir.c index c6f1825..4f60e63 100644 --- a/src/mono/mono/mini/method-to-ir.c +++ b/src/mono/mono/mini/method-to-ir.c @@ -3544,7 +3544,6 @@ handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, Mono int dreg; gpointer trampoline; MonoInst *obj, *tramp_ins; - MonoDomain *domain; guint8 **code_slot; if (virtual_ && !cfg->llvm_only) { @@ -3597,16 +3596,17 @@ handle_delegate_ctor (MonoCompile *cfg, MonoClass *klass, MonoInst *target, Mono if (target_method_context_used) { code_slot_ins = emit_get_rgctx_method (cfg, target_method_context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE); } else { - domain = mono_domain_get (); - mono_domain_lock (domain); - if (!domain_jit_info (domain)->method_code_hash) - domain_jit_info (domain)->method_code_hash = g_hash_table_new (NULL, NULL); - code_slot = (guint8 **)g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method); + MonoJitMemoryManager *jit_mm = (MonoJitMemoryManager*)cfg->jit_mm; + + jit_mm_lock (jit_mm); + if (!jit_mm->method_code_hash) + jit_mm->method_code_hash = g_hash_table_new (NULL, NULL); + code_slot = (guint8 **)g_hash_table_lookup (jit_mm->method_code_hash, method); if (!code_slot) { code_slot = (guint8 **)m_method_alloc0 (method, sizeof (gpointer)); - g_hash_table_insert (domain_jit_info (domain)->method_code_hash, method, code_slot); + g_hash_table_insert (jit_mm->method_code_hash, method, code_slot); } - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); code_slot_ins = mini_emit_runtime_constant (cfg, MONO_PATCH_INFO_METHOD_CODE_SLOT, method); } diff --git a/src/mono/mono/mini/mini-amd64.c b/src/mono/mono/mini/mini-amd64.c index b9fc116..72b4e28 100644 --- a/src/mono/mono/mini/mini-amd64.c +++ b/src/mono/mono/mini/mini-amd64.c @@ -9045,16 +9045,22 @@ mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) { SeqPointInfo *info; MonoJitInfo *ji; + MonoJitMemoryManager *jit_mm; + + /* + * We don't have access to the method etc. so use the global + * memory manager for now. + */ + jit_mm = get_default_jit_mm (); // FIXME: Add a free function - mono_domain_lock (domain); - info = (SeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points, - code); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + info = (SeqPointInfo *)g_hash_table_lookup (jit_mm->arch_seq_points, code); + jit_mm_unlock (jit_mm); if (!info) { - ji = mono_jit_info_table_find (domain, code); + ji = mini_jit_info_table_find (code); g_assert (ji); // FIXME: Optimize the size @@ -9062,10 +9068,9 @@ mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) info->ss_tramp_addr = &ss_trampoline; - mono_domain_lock (domain); - g_hash_table_insert (domain_jit_info (domain)->arch_seq_points, - code, info); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + g_hash_table_insert (jit_mm->arch_seq_points, code, info); + jit_mm_unlock (jit_mm); } return info; diff --git a/src/mono/mono/mini/mini-arm.c b/src/mono/mono/mini/mini-arm.c index e6cadc8..49a63ff 100644 --- a/src/mono/mono/mini/mini-arm.c +++ b/src/mono/mono/mini/mini-arm.c @@ -7379,16 +7379,18 @@ mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) { SeqPointInfo *info; MonoJitInfo *ji; + MonoJitMemoryManager *jit_mm; + + jit_mm = get_default_jit_mm (); // FIXME: Add a free function - mono_domain_lock (domain); - info = (SeqPointInfo*)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points, - code); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + info = (SeqPointInfo *)g_hash_table_lookup (jit_mm->arch_seq_points, code); + jit_mm_unlock (jit_mm); if (!info) { - ji = mono_jit_info_table_find (domain, code); + ji = mini_jit_info_table_find (code); g_assert (ji); info = g_malloc0 (sizeof (SeqPointInfo) + ji->code_size); @@ -7397,10 +7399,9 @@ mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) info->bp_trigger_page = bp_trigger_page; info->ss_tramp_addr = &single_step_tramp; - mono_domain_lock (domain); - g_hash_table_insert (domain_jit_info (domain)->arch_seq_points, - code, info); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + g_hash_table_insert (jit_mm->arch_seq_points, code, info); + jit_mm_unlock (jit_mm); } return info; diff --git a/src/mono/mono/mini/mini-arm64.c b/src/mono/mono/mini/mini-arm64.c index 1958a9d..669ca66 100644 --- a/src/mono/mono/mini/mini-arm64.c +++ b/src/mono/mono/mini/mini-arm64.c @@ -5568,26 +5568,27 @@ mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) { SeqPointInfo *info; MonoJitInfo *ji; + MonoJitMemoryManager *jit_mm; + + jit_mm = get_default_jit_mm (); // FIXME: Add a free function - mono_domain_lock (domain); - info = (SeqPointInfo*)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points, - code); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + info = (SeqPointInfo *)g_hash_table_lookup (jit_mm->arch_seq_points, code); + jit_mm_unlock (jit_mm); if (!info) { - ji = mono_jit_info_table_find (domain, code); + ji = mini_jit_info_table_find (code); g_assert (ji); info = g_malloc0 (sizeof (SeqPointInfo) + (ji->code_size / 4) * sizeof(guint8*)); info->ss_tramp_addr = &ss_trampoline; - mono_domain_lock (domain); - g_hash_table_insert (domain_jit_info (domain)->arch_seq_points, - code, info); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + g_hash_table_insert (jit_mm->arch_seq_points, code, info); + jit_mm_unlock (jit_mm); } return info; diff --git a/src/mono/mono/mini/mini-generic-sharing.c b/src/mono/mono/mini/mini-generic-sharing.c index 69b9205..e49d98f 100644 --- a/src/mono/mono/mini/mini-generic-sharing.c +++ b/src/mono/mono/mini/mini-generic-sharing.c @@ -973,11 +973,12 @@ class_type_info (MonoDomain *domain, MonoClass *klass, MonoRgctxInfoType info_ty case MONO_RGCTX_INFO_BZERO: { static MonoMethod *memcpy_method [17]; static MonoMethod *bzero_method [17]; - MonoJitDomainInfo *domain_info; + MonoJitMemoryManager *jit_mm; int size; guint32 align; - domain_info = domain_jit_info (domain); + /* The memcpy methods are in the default memory alc */ + jit_mm = get_default_jit_mm (); if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (klass))) { size = sizeof (gpointer); @@ -1005,13 +1006,13 @@ class_type_info (MonoDomain *domain, MonoClass *klass, MonoRgctxInfoType info_ty mono_memory_barrier (); memcpy_method [size] = m; } - if (!domain_info->memcpy_addr [size]) { + if (!jit_mm->memcpy_addr [size]) { gpointer addr = mono_compile_method_checked (memcpy_method [size], error); mono_memory_barrier (); - domain_info->memcpy_addr [size] = (gpointer *)addr; + jit_mm->memcpy_addr [size] = (gpointer *)addr; mono_error_assert_ok (error); } - return domain_info->memcpy_addr [size]; + return jit_mm->memcpy_addr [size]; } else { if (!bzero_method [size]) { MonoMethod *m; @@ -1026,13 +1027,13 @@ class_type_info (MonoDomain *domain, MonoClass *klass, MonoRgctxInfoType info_ty mono_memory_barrier (); bzero_method [size] = m; } - if (!domain_info->bzero_addr [size]) { + if (!jit_mm->bzero_addr [size]) { gpointer addr = mono_compile_method_checked (bzero_method [size], error); mono_memory_barrier (); - domain_info->bzero_addr [size] = (gpointer *)addr; + jit_mm->bzero_addr [size] = (gpointer *)addr; mono_error_assert_ok (error); } - return domain_info->bzero_addr [size]; + return jit_mm->bzero_addr [size]; } } case MONO_RGCTX_INFO_NULLABLE_CLASS_BOX: @@ -2009,9 +2010,9 @@ mini_get_gsharedvt_wrapper (gboolean gsharedvt_in, gpointer addr, MonoMethodSign ERROR_DECL (error); gpointer res, info; MonoDomain *domain = mono_domain_get (); - MonoJitDomainInfo *domain_info; GSharedVtTrampInfo *tramp_info; GSharedVtTrampInfo tinfo; + MonoJitMemoryManager *jit_mm; if (mono_llvm_only) { MonoMethod *wrapper; @@ -2033,16 +2034,17 @@ mini_get_gsharedvt_wrapper (gboolean gsharedvt_in, gpointer addr, MonoMethodSign tinfo.sig = normal_sig; tinfo.gsig = gsharedvt_sig; - domain_info = domain_jit_info (domain); + // FIXME: + jit_mm = get_default_jit_mm (); /* * The arg trampolines might only have a finite number in full-aot, so use a cache. */ - mono_domain_lock (domain); - if (!domain_info->gsharedvt_arg_tramp_hash) - domain_info->gsharedvt_arg_tramp_hash = g_hash_table_new (tramp_info_hash, tramp_info_equal); - res = g_hash_table_lookup (domain_info->gsharedvt_arg_tramp_hash, &tinfo); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + if (!jit_mm->gsharedvt_arg_tramp_hash) + jit_mm->gsharedvt_arg_tramp_hash = g_hash_table_new (tramp_info_hash, tramp_info_equal); + res = g_hash_table_lookup (jit_mm->gsharedvt_arg_tramp_hash, &tinfo); + jit_mm_unlock (jit_mm); if (res) return res; @@ -2085,10 +2087,10 @@ mini_get_gsharedvt_wrapper (gboolean gsharedvt_in, gpointer addr, MonoMethodSign tramp_info = (GSharedVtTrampInfo *)mono_domain_alloc0 (domain, sizeof (GSharedVtTrampInfo)); *tramp_info = tinfo; - mono_domain_lock (domain); + jit_mm_lock (jit_mm); /* Duplicates are not a problem */ - g_hash_table_insert (domain_info->gsharedvt_arg_tramp_hash, tramp_info, addr); - mono_domain_unlock (domain); + g_hash_table_insert (jit_mm->gsharedvt_arg_tramp_hash, tramp_info, addr); + jit_mm_unlock (jit_mm); return addr; } @@ -3132,45 +3134,52 @@ mini_method_get_mrgctx (MonoVTable *class_vtable, MonoMethod *method) MonoMethodRuntimeGenericContext *mrgctx; MonoMethodRuntimeGenericContext key; MonoGenericInst *method_inst = mini_method_get_context (method)->method_inst; - MonoJitDomainInfo *domain_info = domain_jit_info (domain); + MonoJitMemoryManager *jit_mm; g_assert (!mono_class_is_gtd (class_vtable->klass)); + jit_mm = jit_mm_for_method (method); + mono_domain_lock (domain); if (!method_inst) { g_assert (mini_method_is_default_method (method)); - if (!domain_info->mrgctx_hash) - domain_info->mrgctx_hash = g_hash_table_new (NULL, NULL); - mrgctx = (MonoMethodRuntimeGenericContext*)g_hash_table_lookup (domain_info->mrgctx_hash, method); + jit_mm_lock (jit_mm); + if (!jit_mm->mrgctx_hash) + jit_mm->mrgctx_hash = g_hash_table_new (NULL, NULL); + mrgctx = (MonoMethodRuntimeGenericContext*)g_hash_table_lookup (jit_mm->mrgctx_hash, method); + jit_mm_unlock (jit_mm); } else { g_assert (!method_inst->is_open); - if (!domain_info->method_rgctx_hash) - domain_info->method_rgctx_hash = g_hash_table_new (mrgctx_hash_func, mrgctx_equal_func); + jit_mm_lock (jit_mm); + if (!jit_mm->method_rgctx_hash) + jit_mm->method_rgctx_hash = g_hash_table_new (mrgctx_hash_func, mrgctx_equal_func); key.class_vtable = class_vtable; key.method_inst = method_inst; - mrgctx = (MonoMethodRuntimeGenericContext *)g_hash_table_lookup (domain_info->method_rgctx_hash, &key); + mrgctx = (MonoMethodRuntimeGenericContext *)g_hash_table_lookup (jit_mm->method_rgctx_hash, &key); + jit_mm_unlock (jit_mm); } if (!mrgctx) { - //int i; - mrgctx = (MonoMethodRuntimeGenericContext*)alloc_rgctx_array (domain, 0, TRUE); mrgctx->class_vtable = class_vtable; mrgctx->method_inst = method_inst; + /* FIXME: The domain lock prevents duplicates */ + jit_mm_lock (jit_mm); if (!method_inst) - g_hash_table_insert (domain_info->mrgctx_hash, method, mrgctx); + g_hash_table_insert (jit_mm->mrgctx_hash, method, mrgctx); else - g_hash_table_insert (domain_info->method_rgctx_hash, mrgctx, mrgctx); + g_hash_table_insert (jit_mm->method_rgctx_hash, mrgctx, mrgctx); + jit_mm_unlock (jit_mm); /* g_print ("mrgctx alloced for %s <", mono_type_get_full_name (class_vtable->klass)); - for (i = 0; i < method_inst->type_argc; ++i) + for (int i = 0; i < method_inst->type_argc; ++i) g_print ("%s, ", mono_type_full_name (method_inst->type_argv [i])); g_print (">\n"); */ diff --git a/src/mono/mono/mini/mini-llvm.c b/src/mono/mono/mini/mini-llvm.c index a2c87fc..d05228c 100644 --- a/src/mono/mono/mini/mini-llvm.c +++ b/src/mono/mono/mini/mini-llvm.c @@ -287,7 +287,7 @@ static MonoLLVMModule aot_module; static GHashTable *intrins_id_to_intrins; static LLVMTypeRef sse_i1_t, sse_i2_t, sse_i4_t, sse_i8_t, sse_r4_t, sse_r8_t; -static void init_jit_module (MonoDomain *domain); +static MonoLLVMModule *init_jit_module (void); static void emit_dbg_loc (EmitContext *ctx, LLVMBuilderRef builder, const unsigned char *cil_code); static void emit_default_dbg_loc (EmitContext *ctx, LLVMBuilderRef builder); @@ -9575,8 +9575,7 @@ mono_llvm_emit_method (MonoCompile *cfg) method_name = mono_aot_get_method_name (cfg); cfg->llvm_method_name = g_strdup (method_name); } else { - init_jit_module (cfg->domain); - ctx->module = (MonoLLVMModule*)domain_jit_info (cfg->domain)->llvm_module; + ctx->module = init_jit_module (); method_name = mono_method_full_name (cfg->method, TRUE); } ctx->method_name = method_name; @@ -10592,10 +10591,9 @@ mono_llvm_cleanup (void) } void -mono_llvm_free_domain_info (MonoDomain *domain) +mono_llvm_free_mem_manager (MonoJitMemoryManager *mem_manager) { - MonoJitDomainInfo *info = domain_jit_info (domain); - MonoLLVMModule *module = (MonoLLVMModule*)info->llvm_module; + MonoLLVMModule *module = (MonoLLVMModule*)mem_manager->llvm_module; int i; if (!module) @@ -10614,7 +10612,7 @@ mono_llvm_free_domain_info (MonoDomain *domain) g_free (module); - info->llvm_module = NULL; + mem_manager->llvm_module = NULL; } void @@ -11646,7 +11644,7 @@ mono_llvm_cleanup (void) } void -mono_llvm_free_domain_info (MonoDomain *domain) +mono_llvm_free_mem_manager (MonoJitMemoryManager *mem_manager) { } @@ -11750,27 +11748,26 @@ decode_llvm_eh_info (EmitContext *ctx, gpointer eh_frame) } } -static void -init_jit_module (MonoDomain *domain) +static MonoLLVMModule* +init_jit_module (void) { - MonoJitDomainInfo *dinfo; + MonoJitMemoryManager *jit_mm; MonoLLVMModule *module; - char *name; - dinfo = domain_jit_info (domain); - if (dinfo->llvm_module) - return; + // FIXME: + jit_mm = get_default_jit_mm (); + if (jit_mm->llvm_module) + return (MonoLLVMModule*)jit_mm->llvm_module; mono_loader_lock (); - if (dinfo->llvm_module) { + if (jit_mm->llvm_module) { mono_loader_unlock (); - return; + return (MonoLLVMModule*)jit_mm->llvm_module; } module = g_new0 (MonoLLVMModule, 1); - name = g_strdup_printf ("mono-%s", domain->friendly_name); module->context = LLVMGetGlobalContext (); module->intrins_by_id = g_new0 (LLVMValueRef, INTRINS_NUM); @@ -11785,17 +11782,17 @@ init_jit_module (MonoDomain *domain) mono_memory_barrier (); - dinfo->llvm_module = module; + jit_mm->llvm_module = module; mono_loader_unlock (); + + return (MonoLLVMModule*)jit_mm->llvm_module; } static void llvm_jit_finalize_method (EmitContext *ctx) { MonoCompile *cfg = ctx->cfg; - MonoDomain *domain = mono_domain_get (); - MonoJitDomainInfo *domain_info; int nvars = g_hash_table_size (ctx->jit_callees); LLVMValueRef *callee_vars = g_new0 (LLVMValueRef, nvars); gpointer *callee_addrs = g_new0 (gpointer, nvars); @@ -11832,25 +11829,27 @@ llvm_jit_finalize_method (EmitContext *ctx) decode_llvm_eh_info (ctx, eh_frame); - mono_domain_lock (domain); - domain_info = domain_jit_info (domain); - if (!domain_info->llvm_jit_callees) - domain_info->llvm_jit_callees = g_hash_table_new (NULL, NULL); + // FIXME: + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + + jit_mm_lock (jit_mm); + if (!jit_mm->llvm_jit_callees) + jit_mm->llvm_jit_callees = g_hash_table_new (NULL, NULL); g_hash_table_iter_init (&iter, ctx->jit_callees); i = 0; while (g_hash_table_iter_next (&iter, (void**)&callee, (void**)&var)) { - GSList *addrs = (GSList*)g_hash_table_lookup (domain_info->llvm_jit_callees, callee); + GSList *addrs = (GSList*)g_hash_table_lookup (jit_mm->llvm_jit_callees, callee); addrs = g_slist_prepend (addrs, callee_addrs [i]); - g_hash_table_insert (domain_info->llvm_jit_callees, callee, addrs); + g_hash_table_insert (jit_mm->llvm_jit_callees, callee, addrs); i ++; } - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); } #else -static void -init_jit_module (MonoDomain *domain) +static MonoLLVMModule* +init_jit_module (void) { g_assert_not_reached (); } diff --git a/src/mono/mono/mini/mini-llvm.h b/src/mono/mono/mini/mini-llvm.h index ad23192..573becc 100644 --- a/src/mono/mono/mini/mini-llvm.h +++ b/src/mono/mono/mini/mini-llvm.h @@ -7,6 +7,7 @@ #include "mini.h" #include "aot-runtime.h" +#include "mini-runtime.h" /* LLVM backend */ @@ -28,7 +29,7 @@ void mono_llvm_emit_aot_file_info (MonoAotFileInfo *info, gboolean has_jit gpointer mono_llvm_emit_aot_data (const char *symbol, guint8 *data, int data_len); gpointer mono_llvm_emit_aot_data_aligned (const char *symbol, guint8 *data, int data_len, int align); void mono_llvm_check_method_supported (MonoCompile *cfg); -void mono_llvm_free_domain_info (MonoDomain *domain); +void mono_llvm_free_mem_manager (MonoJitMemoryManager *mem_manager); MONO_API void mono_personality (void); void mono_llvm_create_vars (MonoCompile *cfg); void mono_llvm_fixup_aot_module (void); diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c index a12bc1c..45145a4 100644 --- a/src/mono/mono/mini/mini-runtime.c +++ b/src/mono/mono/mini/mini-runtime.c @@ -223,9 +223,12 @@ mono_get_method_from_ip (void *ip) if (!ji) { user_data.ip = ip; user_data.method = NULL; - mono_domain_lock (domain); - g_hash_table_foreach (domain_jit_info (domain)->jit_trampoline_hash, find_tramp, &user_data); - mono_domain_unlock (domain); + + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + + jit_mm_lock (jit_mm); + g_hash_table_foreach (jit_mm->jit_trampoline_hash, find_tramp, &user_data); + jit_mm_unlock (jit_mm); if (user_data.method) { char *mname = mono_method_full_name (user_data.method, TRUE); res = g_strdup_printf ("<%p - JIT trampoline for %s>", ip, mname); @@ -312,9 +315,12 @@ mono_print_method_from_ip (void *ip) if (!ji) { user_data.ip = ip; user_data.method = NULL; - mono_domain_lock (domain); - g_hash_table_foreach (domain_jit_info (domain)->jit_trampoline_hash, find_tramp, &user_data); - mono_domain_unlock (domain); + + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + + jit_mm_lock (jit_mm); + g_hash_table_foreach (jit_mm->jit_trampoline_hash, find_tramp, &user_data); + jit_mm_unlock (jit_mm); if (user_data.method) { char *mname = mono_method_full_name (user_data.method, TRUE); @@ -677,14 +683,18 @@ mono_icall_get_wrapper (MonoJitICallInfo* callinfo) } static MonoJitDynamicMethodInfo* -mono_dynamic_code_hash_lookup (MonoDomain *domain, MonoMethod *method) +mono_dynamic_code_hash_lookup (MonoMethod *method) { MonoJitDynamicMethodInfo *res; + MonoJitMemoryManager *jit_mm; - if (domain_jit_info (domain)->dynamic_code_hash) - res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (domain_jit_info (domain)->dynamic_code_hash, method); + jit_mm = jit_mm_for_method (method); + jit_mm_lock (jit_mm); + if (jit_mm->dynamic_code_hash) + res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (jit_mm->dynamic_code_hash, method); else res = NULL; + jit_mm_unlock (jit_mm); return res; } @@ -1418,15 +1428,16 @@ mono_resolve_patch_target (MonoMethod *method, guint8 *code, MonoJumpInfo *patch case MONO_PATCH_INFO_METHOD_CODE_SLOT: { gpointer code_slot; - mono_domain_lock (domain); - if (!domain_jit_info (domain)->method_code_hash) - domain_jit_info (domain)->method_code_hash = g_hash_table_new (NULL, NULL); - code_slot = g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, patch_info->data.method); + MonoJitMemoryManager *jit_mm = jit_mm_for_method (patch_info->data.method); + jit_mm_lock (jit_mm); + if (!jit_mm->method_code_hash) + jit_mm->method_code_hash = g_hash_table_new (NULL, NULL); + code_slot = g_hash_table_lookup (jit_mm->method_code_hash, patch_info->data.method); if (!code_slot) { code_slot = mono_domain_alloc0 (domain, sizeof (gpointer)); - g_hash_table_insert (domain_jit_info (domain)->method_code_hash, patch_info->data.method, code_slot); + g_hash_table_insert (jit_mm->method_code_hash, patch_info->data.method, code_slot); } - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); target = code_slot; break; } @@ -1443,7 +1454,7 @@ mono_resolve_patch_target (MonoMethod *method, guint8 *code, MonoJumpInfo *patch int i; if (method && method->dynamic) { - jump_table = (void **)mono_code_manager_reserve (mono_dynamic_code_hash_lookup (domain, method)->code_mp, sizeof (gpointer) * patch_info->data.table->table_size); + jump_table = (void **)mono_code_manager_reserve (mono_dynamic_code_hash_lookup (method)->code_mp, sizeof (gpointer) * patch_info->data.table->table_size); } else { MonoMemoryManager *mem_manager = m_method_get_mem_manager (method); if (mono_aot_only) { @@ -1707,18 +1718,21 @@ void mini_register_jump_site (MonoDomain *domain, MonoMethod *method, gpointer ip) { MonoJumpList *jlist; + MonoJitMemoryManager *jit_mm; MonoMethod *shared_method = mini_method_to_shared (method); method = shared_method ? shared_method : method; - mono_domain_lock (domain); - jlist = (MonoJumpList *)g_hash_table_lookup (domain_jit_info (domain)->jump_target_hash, method); + jit_mm = jit_mm_for_method (method); + + jit_mm_lock (jit_mm); + jlist = (MonoJumpList *)g_hash_table_lookup (jit_mm->jump_target_hash, method); if (!jlist) { jlist = (MonoJumpList *)mono_domain_alloc0 (domain, sizeof (MonoJumpList)); - g_hash_table_insert (domain_jit_info (domain)->jump_target_hash, method, jlist); + g_hash_table_insert (jit_mm->jump_target_hash, method, jlist); } jlist->list = g_slist_prepend (jlist->list, ip); - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); } /* @@ -1729,11 +1743,7 @@ mini_register_jump_site (MonoDomain *domain, MonoMethod *method, gpointer ip) void mini_patch_jump_sites (MonoDomain *domain, MonoMethod *method, gpointer addr) { - GHashTable *hash = domain_jit_info (domain)->jump_target_hash; - - if (!hash) - return; - + MonoJitMemoryManager *jit_mm; MonoJumpInfo patch_info; MonoJumpList *jlist; GSList *tmp; @@ -1742,11 +1752,14 @@ mini_patch_jump_sites (MonoDomain *domain, MonoMethod *method, gpointer addr) MonoMethod *shared_method = mini_method_to_shared (method); method = shared_method ? shared_method : method; - mono_domain_lock (domain); - jlist = (MonoJumpList *)g_hash_table_lookup (hash, method); + jit_mm = jit_mm_for_method (method); + + jit_mm_lock (jit_mm); + jlist = (MonoJumpList *)g_hash_table_lookup (jit_mm->jump_target_hash, method); if (jlist) - g_hash_table_remove (hash, method); - mono_domain_unlock (domain); + g_hash_table_remove (jit_mm->jump_target_hash, method); + jit_mm_unlock (jit_mm); + if (jlist) { patch_info.next = NULL; patch_info.ip.i = 0; @@ -1770,9 +1783,15 @@ mini_patch_jump_sites (MonoDomain *domain, MonoMethod *method, gpointer addr) void mini_patch_llvm_jit_callees (MonoDomain *domain, MonoMethod *method, gpointer addr) { - if (!domain_jit_info (domain)->llvm_jit_callees) + MonoJitMemoryManager *jit_mm; + + // FIXME: + jit_mm = get_default_jit_mm (); + if (!jit_mm->llvm_jit_callees) return; - GSList *callees = (GSList*)g_hash_table_lookup (domain_jit_info (domain)->llvm_jit_callees, method); + + jit_mm_lock (jit_mm); + GSList *callees = (GSList*)g_hash_table_lookup (jit_mm->llvm_jit_callees, method); GSList *l; for (l = callees; l; l = l->next) { @@ -1780,6 +1799,7 @@ mini_patch_llvm_jit_callees (MonoDomain *domain, MonoMethod *method, gpointer ad *slot = addr; } + jit_mm_unlock (jit_mm); } void @@ -2735,7 +2755,7 @@ mono_jit_free_method (MonoDomain *domain, MonoMethod *method) gboolean destroy = TRUE, removed; GHashTableIter iter; MonoJumpList *jlist; - MonoJitDomainInfo *info = domain_jit_info (domain); + MonoJitMemoryManager *jit_mm; g_assert (method->dynamic); @@ -2743,10 +2763,7 @@ mono_jit_free_method (MonoDomain *domain, MonoMethod *method) mini_get_interp_callbacks ()->free_method (domain, method); } - mono_domain_lock (domain); - ji = mono_dynamic_code_hash_lookup (domain, method); - mono_domain_unlock (domain); - + ji = mono_dynamic_code_hash_lookup (method); if (!ji) return; @@ -2754,21 +2771,23 @@ mono_jit_free_method (MonoDomain *domain, MonoMethod *method) mono_lldb_remove_method (domain, method, ji); mono_domain_lock (domain); - g_hash_table_remove (info->dynamic_code_hash, method); mono_domain_jit_code_hash_lock (domain); removed = mono_internal_hash_table_remove (&domain->jit_code_hash, method); g_assert (removed); mono_domain_jit_code_hash_unlock (domain); - g_hash_table_remove (info->jump_trampoline_hash, method); - g_hash_table_remove (info->seq_points, method); - ji->ji->seq_points = NULL; + mono_domain_unlock (domain); + + jit_mm = jit_mm_for_method (method); - /* requires the domain lock - took above */ - mono_conc_hashtable_remove (info->runtime_invoke_hash, method); + jit_mm_lock (jit_mm); - /* Remove jump targets in this method */ - g_hash_table_iter_init (&iter, info->jump_target_hash); + mono_conc_hashtable_remove (jit_mm->runtime_invoke_hash, method); + g_hash_table_remove (jit_mm->dynamic_code_hash, method); + g_hash_table_remove (jit_mm->jump_trampoline_hash, method); + g_hash_table_remove (jit_mm->seq_points, method); + + g_hash_table_iter_init (&iter, jit_mm->jump_target_hash); while (g_hash_table_iter_next (&iter, NULL, (void**)&jlist)) { GSList *tmp, *remove; @@ -2784,7 +2803,7 @@ mono_jit_free_method (MonoDomain *domain, MonoMethod *method) } g_slist_free (remove); } - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); #ifdef MONO_ARCH_HAVE_INVALIDATE_METHOD if (mini_debug_options.keep_delegates && method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) { @@ -3190,10 +3209,10 @@ mono_jit_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObjec MonoMethod *invoke, *callee; MonoObject *(*runtime_invoke) (MonoObject *this_obj, void **params, MonoObject **exc, void* compiled_method); MonoDomain *domain = mono_domain_get (); - MonoJitDomainInfo *domain_info; RuntimeInvokeInfo *info, *info2; MonoJitInfo *ji = NULL; gboolean callee_gsharedvt = FALSE; + MonoJitMemoryManager *jit_mm; if (mono_ee_features.force_use_interpreter) return mini_get_interp_callbacks ()->runtime_invoke (method, obj, params, exc, error); @@ -3207,9 +3226,9 @@ mono_jit_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObjec return NULL; } - domain_info = domain_jit_info (domain); + jit_mm = jit_mm_for_method (method); - info = (RuntimeInvokeInfo *)mono_conc_hashtable_lookup (domain_info->runtime_invoke_hash, method); + info = (RuntimeInvokeInfo *)mono_conc_hashtable_lookup (jit_mm->runtime_invoke_hash, method); if (!info) { gpointer compiled_method; @@ -3265,9 +3284,9 @@ mono_jit_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObjec if (!is_ok (error)) return NULL; - mono_domain_lock (domain); - info2 = (RuntimeInvokeInfo *)mono_conc_hashtable_insert (domain_info->runtime_invoke_hash, method, info); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + info2 = (RuntimeInvokeInfo *)mono_conc_hashtable_insert (jit_mm->runtime_invoke_hash, method, info); + jit_mm_unlock (jit_mm); if (info2) { g_free (info); info = info2; @@ -4038,21 +4057,21 @@ class_method_pair_hash (gconstpointer data) } static void -mini_create_jit_domain_info (MonoDomain *domain) +init_jit_mem_manager (MonoMemoryManager *mem_manager) { - MonoJitDomainInfo *info = g_new0 (MonoJitDomainInfo, 1); + MonoJitMemoryManager *info = g_new0 (MonoJitMemoryManager, 1); + info->mem_manager = mem_manager; info->jump_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL); + info->jump_target_hash = g_hash_table_new (NULL, NULL); info->jit_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL); info->delegate_trampoline_hash = g_hash_table_new (class_method_pair_hash, class_method_pair_equal); - info->llvm_vcall_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL); - info->runtime_invoke_hash = mono_conc_hashtable_new_full (mono_aligned_addr_hash, NULL, NULL, runtime_invoke_info_free); info->seq_points = g_hash_table_new_full (mono_aligned_addr_hash, NULL, NULL, mono_seq_point_info_free); + info->runtime_invoke_hash = mono_conc_hashtable_new_full (mono_aligned_addr_hash, NULL, NULL, runtime_invoke_info_free); info->arch_seq_points = g_hash_table_new (mono_aligned_addr_hash, NULL); - info->jump_target_hash = g_hash_table_new (NULL, NULL); mono_jit_code_hash_init (&info->interp_code_hash); - domain->runtime_info = info; + mem_manager->runtime_info = info; } static void @@ -4096,9 +4115,9 @@ free_jit_callee_list (gpointer key, gpointer value, gpointer user_data) } static void -mini_free_jit_domain_info (MonoDomain *domain) +free_jit_mem_manager (MonoMemoryManager *mem_manager) { - MonoJitDomainInfo *info = domain_jit_info (domain); + MonoJitMemoryManager *info = (MonoJitMemoryManager*)mem_manager->runtime_info; g_hash_table_foreach (info->jump_target_hash, delete_jump_list, NULL); g_hash_table_destroy (info->jump_target_hash); @@ -4118,12 +4137,11 @@ mini_free_jit_domain_info (MonoDomain *domain) g_hash_table_destroy (info->mrgctx_hash); g_hash_table_destroy (info->method_rgctx_hash); g_hash_table_destroy (info->interp_method_pointer_hash); - g_hash_table_destroy (info->llvm_vcall_trampoline_hash); mono_conc_hashtable_destroy (info->runtime_invoke_hash); g_hash_table_destroy (info->seq_points); g_hash_table_destroy (info->arch_seq_points); if (info->agent_info) - mini_get_dbg_callbacks ()->free_domain_info (domain); + mini_get_dbg_callbacks ()->free_mem_manager (info); g_hash_table_destroy (info->gsharedvt_arg_tramp_hash); if (info->llvm_jit_callees) { g_hash_table_foreach (info->llvm_jit_callees, free_jit_callee_list, NULL); @@ -4131,11 +4149,11 @@ mini_free_jit_domain_info (MonoDomain *domain) } mono_internal_hash_table_destroy (&info->interp_code_hash); #ifdef ENABLE_LLVM - mono_llvm_free_domain_info (domain); + mono_llvm_free_mem_manager (info); #endif - g_free (domain->runtime_info); - domain->runtime_info = NULL; + g_free (info); + mem_manager->runtime_info = NULL; } #ifdef ENABLE_LLVM @@ -4329,6 +4347,8 @@ mini_init (const char *filename, const char *runtime_version) callbacks.metadata_update_init = mini_metadata_update_init; callbacks.metadata_update_published = mini_invalidate_transformed_interp_methods; #endif + callbacks.init_mem_manager = init_jit_mem_manager; + callbacks.free_mem_manager = free_jit_mem_manager; mono_install_callbacks (&callbacks); @@ -4414,10 +4434,6 @@ mini_init (const char *filename, const char *runtime_version) #endif mono_threads_install_cleanup (mini_thread_cleanup); -#ifdef JIT_TRAMPOLINES_WORK - mono_install_create_domain_hook (mini_create_jit_domain_info); - mono_install_free_domain_hook (mini_free_jit_domain_info); -#endif mono_install_get_cached_class_info (mono_aot_get_cached_class_info); mono_install_get_class_from_name (mono_aot_get_class_from_name); mono_install_jit_info_find_in_aot (mono_aot_find_jit_info); diff --git a/src/mono/mono/mini/mini-runtime.h b/src/mono/mono/mini/mini-runtime.h index e0444ea..c6a665a 100644 --- a/src/mono/mono/mini/mini-runtime.h +++ b/src/mono/mono/mini/mini-runtime.h @@ -15,9 +15,12 @@ #include "mini.h" #include "ee.h" -/* Per-domain information maintained by the JIT */ -typedef struct -{ +/* + * Per-memory manager information maintained by the JIT. + */ +typedef struct { + MonoMemoryManager *mem_manager; + /* Maps MonoMethod's to a GSList of GOT slot addresses pointing to its code */ GHashTable *jump_target_got_slot_hash; GHashTable *jump_target_hash; @@ -27,7 +30,6 @@ typedef struct GHashTable *delegate_trampoline_hash; /* Maps ClassMethodPair -> MonoDelegateTrampInfo */ GHashTable *static_rgctx_trampoline_hash; - GHashTable *llvm_vcall_trampoline_hash; /* maps MonoMethod -> MonoJitDynamicMethodInfo */ GHashTable *dynamic_code_hash; GHashTable *method_code_hash; @@ -55,9 +57,36 @@ typedef struct GHashTable *method_rgctx_hash; /* Maps gpointer -> InterpMethod */ GHashTable *interp_method_pointer_hash; -} MonoJitDomainInfo; +} MonoJitMemoryManager; + +static inline MonoJitMemoryManager* +get_default_jit_mm (void) +{ + return (MonoJitMemoryManager*)(mono_domain_ambient_memory_manager (mono_get_root_domain ()))->runtime_info; +} + +static inline MonoJitMemoryManager* +jit_mm_for_method (MonoMethod *method) +{ + /* + * Some places might not look up the correct memory manager because of generic instances/generic sharing etc. + * So use the same memory manager everywhere, this is not a problem since we don't support unloading yet. + */ + //return (MonoJitMemoryManager*)m_method_get_mem_manager (method)->runtime_info; + return get_default_jit_mm (); +} -#define domain_jit_info(domain) ((MonoJitDomainInfo*)((domain)->runtime_info)) +static inline void +jit_mm_lock (MonoJitMemoryManager *jit_mm) +{ + mono_mem_manager_lock (jit_mm->mem_manager); +} + +static inline void +jit_mm_unlock (MonoJitMemoryManager *jit_mm) +{ + mono_mem_manager_unlock (jit_mm->mem_manager); +} /* * Stores state need to resume exception handling when using LLVM diff --git a/src/mono/mono/mini/mini-s390x.c b/src/mono/mono/mini/mini-s390x.c index a6bbd3c..8693367 100644 --- a/src/mono/mono/mini/mini-s390x.c +++ b/src/mono/mono/mini/mini-s390x.c @@ -6845,13 +6845,16 @@ mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) { SeqPointInfo *info; MonoJitInfo *ji; + MonoJitMemoryManager *jit_mm; - mono_domain_lock (domain); - info = (SeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points, code); - mono_domain_unlock (domain); + jit_mm = get_default_jit_mm (); + + jit_mm_lock (jit_mm); + info = (SeqPointInfo *)g_hash_table_lookup (jit_mm->arch_seq_points, code); + jit_mm_unlock (jit_mm); if (!info) { - ji = mono_jit_info_table_find (domain, code); + ji = mini_jit_info_table_find (code); g_assert (ji); // FIXME: Optimize the size @@ -6859,9 +6862,9 @@ mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) info->ss_tramp_addr = &ss_trampoline; - mono_domain_lock (domain); - g_hash_table_insert (domain_jit_info(domain)->arch_seq_points, code, info); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + g_hash_table_insert (jit_mm->arch_seq_points, code, info); + jit_mm_unlock (jit_mm); } return info; diff --git a/src/mono/mono/mini/mini-trampolines.c b/src/mono/mono/mini/mini-trampolines.c index 82e85d7..b156637 100644 --- a/src/mono/mono/mini/mini-trampolines.c +++ b/src/mono/mono/mini/mini-trampolines.c @@ -97,10 +97,9 @@ mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr) { gpointer ctx; gpointer res; - MonoDomain *domain; RgctxTrampInfo tmp_info; RgctxTrampInfo *info; - MonoMemoryManager *mem_manager; + MonoJitMemoryManager *jit_mm; #ifdef PPC_USES_FUNCTION_DESCRIPTOR g_assert (((gpointer*)addr) [2] == 0); @@ -108,38 +107,36 @@ mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr) ctx = mini_method_get_rgctx (m); - domain = mono_domain_get (); - mem_manager = m_method_get_mem_manager (m); + jit_mm = jit_mm_for_method (m); /* * In the AOT case, addr might point to either the method, or to an unbox trampoline, * so make the hash keyed on the m+addr pair. */ - mono_domain_lock (domain); - if (!domain_jit_info (domain)->static_rgctx_trampoline_hash) - domain_jit_info (domain)->static_rgctx_trampoline_hash = g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal); + jit_mm_lock (jit_mm); + if (!jit_mm->static_rgctx_trampoline_hash) + jit_mm->static_rgctx_trampoline_hash = g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal); tmp_info.m = m; tmp_info.addr = addr; - res = g_hash_table_lookup (domain_jit_info (domain)->static_rgctx_trampoline_hash, + res = g_hash_table_lookup (jit_mm->static_rgctx_trampoline_hash, &tmp_info); - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); if (res) return res; if (mono_aot_only) res = mono_aot_get_static_rgctx_trampoline (ctx, addr); else - res = mono_arch_get_static_rgctx_trampoline (mem_manager, ctx, addr); + res = mono_arch_get_static_rgctx_trampoline (jit_mm->mem_manager, ctx, addr); - mono_domain_lock (domain); + jit_mm_lock (jit_mm); /* Duplicates inserted while we didn't hold the lock are OK */ info = (RgctxTrampInfo *)m_method_alloc (m, sizeof (RgctxTrampInfo)); info->m = m; info->addr = addr; - g_hash_table_insert (domain_jit_info (domain)->static_rgctx_trampoline_hash, info, res); - + g_hash_table_insert (jit_mm->static_rgctx_trampoline_hash, info, res); UnlockedIncrement (&static_rgctx_trampolines); - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); return res; } @@ -669,22 +666,24 @@ common_call_trampoline (host_mgreg_t *regs, guint8 *code, MonoMethod *m, MonoVTa * We do this here instead of in mono_codegen () to cover the case when m * was loaded from an aot image. */ - if (domain_jit_info (domain)->jump_target_got_slot_hash) { - GSList *list, *tmp; - MonoMethod *shared_method = mini_method_to_shared (m); - m = shared_method ? shared_method : m; - - mono_domain_lock (domain); - list = (GSList *)g_hash_table_lookup (domain_jit_info (domain)->jump_target_got_slot_hash, m); + MonoJitMemoryManager *jit_mm; + GSList *list, *tmp; + MonoMethod *shared_method = mini_method_to_shared (m); + m = shared_method ? shared_method : m; + jit_mm = jit_mm_for_method (m); + + if (jit_mm->jump_target_got_slot_hash) { + jit_mm_lock (jit_mm); + list = (GSList *)g_hash_table_lookup (jit_mm->jump_target_got_slot_hash, m); if (list) { for (tmp = list; tmp; tmp = tmp->next) { gpointer *got_slot = (gpointer *)tmp->data; *got_slot = addr; } - g_hash_table_remove (domain_jit_info (domain)->jump_target_got_slot_hash, m); + g_hash_table_remove (jit_mm->jump_target_got_slot_hash, m); g_slist_free (list); } - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); } return addr; @@ -1271,6 +1270,7 @@ mono_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, M gpointer mono_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper, MonoError *error) { + MonoJitMemoryManager *jit_mm; MonoJitInfo *ji; gpointer code; guint32 code_size = 0; @@ -1284,7 +1284,7 @@ mono_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean ad return ret; } - code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji); + code = mono_jit_find_compiled_method_with_jit_info (mono_get_root_domain (), method, &ji); /* * We cannot recover the correct type of a shared generic * method from its native code address, so we use the @@ -1301,9 +1301,11 @@ mono_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean ad return code; } - mono_domain_lock (domain); - code = g_hash_table_lookup (domain_jit_info (domain)->jump_trampoline_hash, method); - mono_domain_unlock (domain); + jit_mm = jit_mm_for_method (method); + + jit_mm_lock (jit_mm); + code = g_hash_table_lookup (jit_mm->jump_trampoline_hash, method); + jit_mm_unlock (jit_mm); if (code) return code; @@ -1322,9 +1324,9 @@ mono_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean ad mono_jit_info_table_add (domain, ji); - mono_domain_lock (domain); - g_hash_table_insert (domain_jit_info (domain)->jump_trampoline_hash, method, code); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + g_hash_table_insert (jit_mm->jump_trampoline_hash, method, code); + jit_mm_unlock (jit_mm); return code; } @@ -1338,6 +1340,7 @@ method_not_found (void) gpointer mono_create_jit_trampoline (MonoDomain *domain, MonoMethod *method, MonoError *error) { + MonoJitMemoryManager *jit_mm; gpointer tramp; error_init (error); @@ -1360,18 +1363,20 @@ mono_create_jit_trampoline (MonoDomain *domain, MonoMethod *method, MonoError *e } } - mono_domain_lock (domain); - tramp = g_hash_table_lookup (domain_jit_info (domain)->jit_trampoline_hash, method); - mono_domain_unlock (domain); + jit_mm = jit_mm_for_method (method); + + jit_mm_lock (jit_mm); + tramp = g_hash_table_lookup (jit_mm->jit_trampoline_hash, method); + jit_mm_unlock (jit_mm); if (tramp) return tramp; tramp = mono_create_specific_trampoline (method, MONO_TRAMPOLINE_JIT, domain, NULL); - - mono_domain_lock (domain); - g_hash_table_insert (domain_jit_info (domain)->jit_trampoline_hash, method, tramp); + + jit_mm_lock (jit_mm); + g_hash_table_insert (jit_mm->jit_trampoline_hash, method, tramp); UnlockedIncrement (&jit_trampolines); - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); return tramp; } @@ -1411,12 +1416,16 @@ mono_create_delegate_trampoline_info (MonoDomain *domain, MonoClass *klass, Mono MonoDelegateTrampInfo *tramp_info; MonoClassMethodPair pair, *dpair; guint32 code_size = 0; + MonoJitMemoryManager *jit_mm; pair.klass = klass; pair.method = method; - mono_domain_lock (domain); - tramp_info = (MonoDelegateTrampInfo *)g_hash_table_lookup (domain_jit_info (domain)->delegate_trampoline_hash, &pair); - mono_domain_unlock (domain); + + // FIXME: Use the proper memory manager + jit_mm = get_default_jit_mm (); + jit_mm_lock (jit_mm); + tramp_info = (MonoDelegateTrampInfo *)g_hash_table_lookup (jit_mm->delegate_trampoline_hash, &pair); + jit_mm_unlock (jit_mm); if (tramp_info) return tramp_info; @@ -1441,9 +1450,9 @@ mono_create_delegate_trampoline_info (MonoDomain *domain, MonoClass *klass, Mono memcpy (dpair, &pair, sizeof (MonoClassMethodPair)); /* store trampoline address */ - mono_domain_lock (domain); - g_hash_table_insert (domain_jit_info (domain)->delegate_trampoline_hash, dpair, tramp_info); - mono_domain_unlock (domain); + jit_mm_lock (jit_mm); + g_hash_table_insert (jit_mm->delegate_trampoline_hash, dpair, tramp_info); + jit_mm_unlock (jit_mm); return tramp_info; } diff --git a/src/mono/mono/mini/mini.c b/src/mono/mono/mini/mini.c index f49e228..1e00a16 100644 --- a/src/mono/mono/mini/mini.c +++ b/src/mono/mono/mini/mini.c @@ -949,26 +949,6 @@ mini_assembly_can_skip_verification (MonoDomain *domain, MonoMethod *method) return mono_assembly_has_skip_verification (assembly); } -static void -mono_dynamic_code_hash_insert (MonoDomain *domain, MonoMethod *method, MonoJitDynamicMethodInfo *ji) -{ - if (!domain_jit_info (domain)->dynamic_code_hash) - domain_jit_info (domain)->dynamic_code_hash = g_hash_table_new (NULL, NULL); - g_hash_table_insert (domain_jit_info (domain)->dynamic_code_hash, method, ji); -} - -static MonoJitDynamicMethodInfo* -mono_dynamic_code_hash_lookup (MonoDomain *domain, MonoMethod *method) -{ - MonoJitDynamicMethodInfo *res; - - if (domain_jit_info (domain)->dynamic_code_hash) - res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (domain_jit_info (domain)->dynamic_code_hash, method); - else - res = NULL; - return res; -} - typedef struct { MonoClass *vtype; GList *active, *inactive; @@ -2147,9 +2127,13 @@ mono_codegen (MonoCompile *cfg) /* Allocate the code into a separate memory pool so it can be freed */ cfg->dynamic_info = g_new0 (MonoJitDynamicMethodInfo, 1); cfg->dynamic_info->code_mp = mono_code_manager_new_dynamic (); - mono_domain_lock (cfg->domain); - mono_dynamic_code_hash_insert (cfg->domain, cfg->method, cfg->dynamic_info); - mono_domain_unlock (cfg->domain); + + MonoJitMemoryManager *jit_mm = (MonoJitMemoryManager*)cfg->jit_mm; + jit_mm_lock (jit_mm); + if (!jit_mm->dynamic_code_hash) + jit_mm->dynamic_code_hash = g_hash_table_new (NULL, NULL); + g_hash_table_insert (jit_mm->dynamic_code_hash, cfg->method, cfg->dynamic_info); + jit_mm_unlock (jit_mm); if (mono_using_xdebug) /* See the comment for cfg->code_domain */ @@ -3103,6 +3087,7 @@ mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, JitFl cfg->self_init = (flags & JIT_FLAG_SELF_INIT) != 0; cfg->code_exec_only = (flags & JIT_FLAG_CODE_EXEC_ONLY) != 0; cfg->backend = current_backend; + cfg->jit_mm = jit_mm_for_method (cfg->method); cfg->mem_manager = m_method_get_mem_manager (cfg->method); if (cfg->method->wrapper_type == MONO_WRAPPER_ALLOC) { @@ -3820,13 +3805,21 @@ mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, JitFl if (!cfg->compile_aot && !(flags & JIT_FLAG_DISCARD_RESULTS)) { mono_domain_lock (cfg->domain); mono_jit_info_table_add (cfg->domain, cfg->jit_info); + mono_domain_unlock (cfg->domain); - if (cfg->method->dynamic) - mono_dynamic_code_hash_lookup (cfg->domain, cfg->method)->ji = cfg->jit_info; + if (cfg->method->dynamic) { + MonoJitMemoryManager *jit_mm = (MonoJitMemoryManager*)cfg->jit_mm; + MonoJitDynamicMethodInfo *res; - mono_postprocess_patches_after_ji_publish (cfg); + jit_mm_lock (jit_mm); + g_assert (jit_mm->dynamic_code_hash); + res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (jit_mm->dynamic_code_hash, method); + jit_mm_unlock (jit_mm); + g_assert (res); + res->ji = cfg->jit_info; + } - mono_domain_unlock (cfg->domain); + mono_postprocess_patches_after_ji_publish (cfg); } #if 0 diff --git a/src/mono/mono/mini/mini.h b/src/mono/mono/mini/mini.h index f30fdae..f748732 100644 --- a/src/mono/mono/mini/mini.h +++ b/src/mono/mono/mini/mini.h @@ -1352,6 +1352,7 @@ typedef struct { MonoGSharedVtMethodInfo *gsharedvt_info; + gpointer jit_mm; MonoMemoryManager *mem_manager; /* Points to the gsharedvt locals area at runtime */ diff --git a/src/mono/mono/mini/seq-points.c b/src/mono/mono/mini/seq-points.c index 50d7dbf..502a4d2 100644 --- a/src/mono/mono/mini/seq-points.c +++ b/src/mono/mono/mini/seq-points.c @@ -104,7 +104,6 @@ mono_save_seq_point_info (MonoCompile *cfg, MonoJitInfo *jinfo) MonoBasicBlock *bb; GSList *bb_seq_points, *l; MonoInst *last; - MonoDomain *domain = cfg->domain; int i, seq_info_size; GSList **next = NULL; SeqPoint* seq_points; @@ -238,13 +237,15 @@ mono_save_seq_point_info (MonoCompile *cfg, MonoJitInfo *jinfo) // FIXME: dynamic methods if (!cfg->compile_aot) { - mono_domain_lock (domain); + // FIXME: + MonoJitMemoryManager *jit_mm = get_default_jit_mm (); + jit_mm_lock (jit_mm); // FIXME: The lookup can fail if the method is JITted recursively though a type cctor - if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, cfg->method_to_register)) - g_hash_table_insert (domain_jit_info (domain)->seq_points, cfg->method_to_register, cfg->seq_point_info); + if (!g_hash_table_lookup (jit_mm->seq_points, cfg->method_to_register)) + g_hash_table_insert (jit_mm->seq_points, cfg->method_to_register, cfg->seq_point_info); else mono_seq_point_info_free (cfg->seq_point_info); - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); g_assert (jinfo); jinfo->seq_points = cfg->seq_point_info; @@ -261,6 +262,7 @@ mono_get_seq_points (MonoDomain *domain, MonoMethod *method) ERROR_DECL (error); MonoSeqPointInfo *seq_points; MonoMethod *declaring_generic_method = NULL, *shared_method = NULL; + MonoJitMemoryManager *jit_mm; if (method->is_inflated) { declaring_generic_method = mono_method_get_declaring_generic_method (method); @@ -268,15 +270,17 @@ mono_get_seq_points (MonoDomain *domain, MonoMethod *method) mono_error_assert_ok (error); } - mono_domain_lock (domain); - seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, method); + // FIXME: + jit_mm = get_default_jit_mm (); + jit_mm_lock (jit_mm); + seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (jit_mm->seq_points, method); if (!seq_points && method->is_inflated) { /* generic sharing + aot */ - seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, declaring_generic_method); + seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (jit_mm->seq_points, declaring_generic_method); if (!seq_points) - seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, shared_method); + seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (jit_mm->seq_points, shared_method); } - mono_domain_unlock (domain); + jit_mm_unlock (jit_mm); return seq_points; } -- 2.7.4