mono/metadata/memory-manager.c

   1 #include <mono/metadata/loader-internals.h>
   2 #include <mono/metadata/gc-internals.h>
   3 #include <mono/metadata/reflection-cache.h>
   4 #include <mono/metadata/mono-hash-internals.h>
   5
   6 static void
   7 memory_manager_init (MonoMemoryManager *memory_manager, MonoDomain *domain, gboolean collectible)
   8 {
   9         memory_manager->domain = domain;
  10         memory_manager->freeing = FALSE;
  11
  12         mono_coop_mutex_init_recursive (&memory_manager->lock);
  13
  14         memory_manager->mp = mono_mempool_new ();
  15         memory_manager->code_mp = mono_code_manager_new ();
  16
  17         memory_manager->class_vtable_array = g_ptr_array_new ();
  18
  19         // TODO: make these not linked to the domain for debugging
  20         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");
  21         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");
  22         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");
  23 }
  24
  25 MonoSingletonMemoryManager *
  26 mono_mem_manager_create_singleton (MonoAssemblyLoadContext *alc, MonoDomain *domain, gboolean collectible)
  27 {
  28         MonoSingletonMemoryManager *mem_manager = g_new0 (MonoSingletonMemoryManager, 1);
  29         memory_manager_init ((MonoMemoryManager *)mem_manager, domain, collectible);
  30
  31         mem_manager->memory_manager.is_generic = FALSE;
  32         mem_manager->alc = alc;
  33
  34         return mem_manager;
  35 }
  36
  37 static void
  38 cleanup_refobject_hash (gpointer key, gpointer value, gpointer user_data)
  39 {
  40         free_reflected_entry ((ReflectedEntry *)key);
  41 }
  42
  43 static void
  44 unregister_vtable_reflection_type (MonoVTable *vtable)
  45 {
  46         MonoObject *type = (MonoObject *)vtable->type;
  47
  48         if (type->vtable->klass != mono_defaults.runtimetype_class)
  49                 MONO_GC_UNREGISTER_ROOT_IF_MOVING (vtable->type);
  50 }
  51
  52 // First phase of deletion
  53 static void
  54 memory_manager_delete_objects (MonoMemoryManager *memory_manager)
  55 {
  56         memory_manager->freeing = TRUE;
  57
  58         // Must be done before type_hash is freed
  59         for (int i = 0; i < memory_manager->class_vtable_array->len; i++)
  60                 unregister_vtable_reflection_type ((MonoVTable *)g_ptr_array_index (memory_manager->class_vtable_array, i));
  61
  62         g_ptr_array_free (memory_manager->class_vtable_array, TRUE);
  63         memory_manager->class_vtable_array = NULL;
  64         mono_g_hash_table_destroy (memory_manager->type_hash);
  65         memory_manager->type_hash = NULL;
  66         mono_conc_g_hash_table_foreach (memory_manager->refobject_hash, cleanup_refobject_hash, NULL);
  67         mono_conc_g_hash_table_destroy (memory_manager->refobject_hash);
  68         memory_manager->refobject_hash = NULL;
  69         mono_g_hash_table_destroy (memory_manager->type_init_exception_hash);
  70         memory_manager->type_init_exception_hash = NULL;
  71 }
  72
  73 // Full deletion
  74 static void
  75 memory_manager_delete (MonoMemoryManager *memory_manager, gboolean debug_unload)
  76 {
  77         // Scan here to assert no lingering references in vtables?
  78
  79         if (!memory_manager->freeing)
  80                 memory_manager_delete_objects (memory_manager);
  81
  82         mono_coop_mutex_destroy (&memory_manager->lock);
  83
  84         if (debug_unload) {
  85                 mono_mempool_invalidate (memory_manager->mp);
  86                 mono_code_manager_invalidate (memory_manager->code_mp);
  87         } else {
  88 #ifndef DISABLE_PERFCOUNTERS
  89                 /* FIXME: use an explicit subtraction method as soon as it's available */
  90                 mono_atomic_fetch_add_i32 (&mono_perfcounters->loader_bytes, -1 * mono_mempool_get_allocated (memory_manager->mp));
  91 #endif
  92                 mono_mempool_destroy (memory_manager->mp);
  93                 memory_manager->mp = NULL;
  94                 mono_code_manager_destroy (memory_manager->code_mp);
  95                 memory_manager->code_mp = NULL;
  96         }
  97 }
  98
  99 void
 100 mono_mem_manager_free_objects_singleton (MonoSingletonMemoryManager *memory_manager)
 101 {
 102         g_assert (!memory_manager->memory_manager.freeing);
 103
 104         memory_manager_delete_objects (&memory_manager->memory_manager);
 105 }
 106
 107 void
 108 mono_mem_manager_free_singleton (MonoSingletonMemoryManager *memory_manager, gboolean debug_unload)
 109 {
 110         g_assert (!memory_manager->memory_manager.is_generic);
 111
 112         memory_manager_delete (&memory_manager->memory_manager, debug_unload);
 113         g_free (memory_manager);
 114 }
 115
 116 void
 117 mono_mem_manager_lock (MonoMemoryManager *memory_manager)
 118 {
 119         //mono_coop_mutex_lock (&memory_manager->lock);
 120         mono_domain_lock (memory_manager->domain);
 121 }
 122
 123 void
 124 mono_mem_manager_unlock (MonoMemoryManager *memory_manager)
 125 {
 126         //mono_coop_mutex_unlock (&memory_manager->lock);
 127         mono_domain_unlock (memory_manager->domain);
 128 }
 129
 130 void *
 131 mono_mem_manager_alloc (MonoMemoryManager *memory_manager, guint size)
 132 {
 133         void *res;
 134
 135         mono_mem_manager_lock (memory_manager);
 136         res = mono_mem_manager_alloc_nolock (memory_manager, size);
 137         mono_mem_manager_unlock (memory_manager);
 138
 139         return res;
 140 }
 141
 142 void *
 143 mono_mem_manager_alloc_nolock (MonoMemoryManager *memory_manager, guint size)
 144 {
 145 #ifndef DISABLE_PERFCOUNTERS
 146         mono_atomic_fetch_add_i32 (&mono_perfcounters->loader_bytes, size);
 147 #endif
 148         return mono_mempool_alloc (memory_manager->mp, size);
 149 }
 150
 151 void *
 152 mono_mem_manager_alloc0 (MonoMemoryManager *memory_manager, guint size)
 153 {
 154         void *res;
 155
 156         mono_mem_manager_lock (memory_manager);
 157         res = mono_mem_manager_alloc0_nolock (memory_manager, size);
 158         mono_mem_manager_unlock (memory_manager);
 159
 160         return res;
 161 }
 162
 163 void *
 164 mono_mem_manager_alloc0_nolock (MonoMemoryManager *memory_manager, guint size)
 165 {
 166 #ifndef DISABLE_PERFCOUNTERS
 167         mono_atomic_fetch_add_i32 (&mono_perfcounters->loader_bytes, size);
 168 #endif
 169         return mono_mempool_alloc0 (memory_manager->mp, size);
 170 }
 171
 172 char*
 173 mono_mem_manager_strdup (MonoMemoryManager *memory_manager, const char *s)
 174 {
 175         char *res;
 176
 177         mono_mem_manager_lock (memory_manager);
 178         res = mono_mempool_strdup (memory_manager->mp, s);
 179         mono_mem_manager_unlock (memory_manager);
 180
 181         return res;
 182 }
 183
 184 void *
 185 (mono_mem_manager_code_reserve) (MonoMemoryManager *memory_manager, int size)
 186 {
 187         void *res;
 188
 189         mono_mem_manager_lock (memory_manager);
 190         res = mono_code_manager_reserve (memory_manager->code_mp, size);
 191         mono_mem_manager_unlock (memory_manager);
 192
 193         return res;
 194 }
 195
 196 void *
 197 mono_mem_manager_code_reserve_align (MonoMemoryManager *memory_manager, int size, int alignment)
 198 {
 199         void *res;
 200
 201         mono_mem_manager_lock (memory_manager);
 202         res = mono_code_manager_reserve_align (memory_manager->code_mp, size, alignment);
 203         mono_mem_manager_unlock (memory_manager);
 204
 205         return res;
 206 }
 207
 208 void
 209 mono_mem_manager_code_commit (MonoMemoryManager *memory_manager, void *data, int size, int newsize)
 210 {
 211         mono_mem_manager_lock (memory_manager);
 212         mono_code_manager_commit (memory_manager->code_mp, data, size, newsize);
 213         mono_mem_manager_unlock (memory_manager);
 214 }
 215
 216 /*
 217  * mono_mem_manager_code_foreach:
 218  * Iterate over the code thunks of the code manager of @memory_manager.
 219  *
 220  * The @func callback MUST not take any locks. If it really needs to, it must respect
 221  * the locking rules of the runtime: http://www.mono-project.com/Mono:Runtime:Documentation:ThreadSafety
 222  * LOCKING: Acquires the memory manager lock.
 223  */
 224 void
 225 mono_mem_manager_code_foreach (MonoMemoryManager *memory_manager, MonoCodeManagerFunc func, void *user_data)
 226 {
 227         mono_mem_manager_lock (memory_manager);
 228         mono_code_manager_foreach (memory_manager->code_mp, func, user_data);
 229         mono_mem_manager_unlock (memory_manager);
 230 }