Merge pull request #959 from Unity-Technologies/memory-snapshot-unity-master

Unity Memory Snapshot Support for .NET 4.x

Author: lukaszunity

mono/metadata/appdomain.h

@@ -26,6 +26,7 @@ typedef struct _MonoAppDomain MonoAppDomain;
 typedef struct _MonoJitInfo MonoJitInfo;
 
 typedef void (*MonoDomainFunc) (MonoDomain *domain, void* user_data);
+typedef void (*MonoDomainAssemblyFunc) (MonoAssembly *assembly, void* user_data);
 
 MONO_API MonoDomain*
 mono_init                  (const char *filename);
@@ -108,6 +109,9 @@ mono_domain_from_appdomain (MonoAppDomain *appdomain);
 MONO_API void
 mono_domain_foreach        (MonoDomainFunc func, void* user_data);
 
+MONO_API void
+mono_domain_assembly_foreach (MonoDomain* domain, MonoDomainAssemblyFunc func, void* user_data);
+
 MONO_API MonoAssembly *
 mono_domain_assembly_open  (MonoDomain *domain, const char *name);
 

mono/metadata/boehm-gc.c

@@ -2027,7 +2027,7 @@ mono_gchandle_free_domain (MonoDomain *domain)
 {
 	guint type;
 
-	for (type = HANDLE_TYPE_MIN; type < HANDLE_PINNED; ++type) {
+	for (type = HANDLE_TYPE_MIN; type <= HANDLE_PINNED; ++type) {
 		guint slot;
 		HandleData *handles = &gc_handles [type];
 		lock_handles (handles);
@@ -2058,6 +2058,30 @@ mono_gc_register_obj_with_weak_fields (void *obj)
 	g_error ("Weak fields not supported by boehm gc");
 }
 
+void
+mono_gc_strong_handle_foreach(GFunc func, gpointer user_data)
+{
+	int gcHandleTypeIndex;
+	uint32_t i;
+
+	lock_handles(handles);
+
+	for (gcHandleTypeIndex = HANDLE_NORMAL; gcHandleTypeIndex <= HANDLE_PINNED; gcHandleTypeIndex++)
+	{
+		HandleData* handles = &gc_handles[gcHandleTypeIndex];
+
+		for (i = 0; i < handles->size; i++)
+		{			
+			if (!slot_occupied(handles, i))
+				continue;
+			if (handles->entries[i] != NULL)
+				func(handles->entries[i], user_data);
+		}
+	}
+
+	unlock_handles(handles);
+}
+
 #else
 
 MONO_EMPTY_SOURCE_FILE (boehm_gc);

mono/metadata/domain.c

@@ -982,6 +982,27 @@ mono_domain_foreach (MonoDomainFunc func, gpointer user_data)
 	gc_free_fixed_non_heap_list (copy);
 }
 
+MONO_API void
+mono_domain_assembly_foreach (MonoDomain* domain, MonoDomainAssemblyFunc func, void* user_data)
+{
+	MonoAssembly* assembly;
+	GSList *iter;
+
+	/* Skipping internal assembly builders created by remoting,
+	   as it is done in ves_icall_System_AppDomain_GetAssemblies
+	*/
+	mono_domain_assemblies_lock(domain);
+	for (iter = domain->domain_assemblies; iter; iter = iter->next) 
+	{
+		assembly = (MonoAssembly *)iter->data;
+		if (assembly->corlib_internal)
+			continue;
+
+		func(assembly, user_data);
+	}
+	mono_domain_assemblies_unlock(domain);
+}
+
 /* FIXME: maybe we should integrate this with mono_assembly_open? */
 /**
  * mono_domain_assembly_open:

mono/metadata/gc-internals.h

@@ -140,6 +140,8 @@ MonoGCDescriptor mono_gc_make_descr_for_string (gsize *bitmap, int numbits);
 
 void mono_gc_register_obj_with_weak_fields (void *obj);
 
+void mono_gc_strong_handle_foreach(GFunc func, gpointer user_data);
+
 void  mono_gc_register_for_finalization (MonoObject *obj, void *user_data);
 void  mono_gc_add_memory_pressure (gint64 value);
 MONO_API int   mono_gc_register_root (char *start, size_t size, MonoGCDescriptor descr, MonoGCRootSource source, void *key, const char *msg);

mono/metadata/mempool.c

@@ -434,3 +434,21 @@ mono_mempool_get_bytes_allocated (void)
 {
 	return UnlockedRead64 (&total_bytes_allocated);
 }
+
+void 
+mono_mempool_foreach_block(MonoMemPool* pool, mono_mempool_block_proc callback, void* user_data)
+{
+	MonoMemPool *current = pool;
+
+	while (current)
+	{
+		gpointer start = (guint8*)current + SIZEOF_MEM_POOL;
+		gpointer end = (guint8*)start + current->size;
+
+		callback(start, end, user_data);
+		current = current->next;
+	}
+}
+
+
+

mono/metadata/mempool.h

@@ -41,6 +41,11 @@ mono_mempool_strdup        (MonoMemPool *pool, const char *s);
 MONO_API uint32_t
 mono_mempool_get_allocated (MonoMemPool *pool);
 
+typedef void(*mono_mempool_block_proc)(void* start, void* end, void* user_data);
+
+MONO_API void
+mono_mempool_foreach_block(MonoMemPool* pool, mono_mempool_block_proc callback, void* user_data);
+
 MONO_END_DECLS
 
 #endif

mono/metadata/metadata-internals.h

@@ -621,6 +621,8 @@ typedef struct {
 	char *aot_options;
 } MonoAotCacheConfig;
 
+typedef void(*MonoImageSetFunc) (MonoImageSet *imageSet, void* user_data);
+
 #define MONO_SIZEOF_METHOD_SIGNATURE (sizeof (struct _MonoMethodSignature) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P)
 
 static inline gboolean
@@ -722,6 +724,8 @@ mono_image_set_unlock (MonoImageSet *set);
 char*
 mono_image_set_strdup (MonoImageSet *set, const char *s);
 
+void mono_metadata_image_set_foreach(MonoImageSetFunc func, gpointer user_data);
+
 #define mono_image_set_new0(image,type,size) ((type *) mono_image_set_alloc0 (image, sizeof (type)* (size)))
 
 gboolean

mono/metadata/metadata.c

@@ -5080,6 +5080,66 @@ mono_metadata_generic_class_is_valuetype (MonoGenericClass *gclass)
 	return gclass->container_class->valuetype;
 }
 
+typedef struct
+{
+	MonoGenericClassFunc func;
+	gpointer user_data;
+} GenericClassForeachData;
+
+
+static void
+generic_class_foreach_callback(gpointer key, gpointer value, gpointer user_data)
+{
+	GenericClassForeachData* data = (GenericClassForeachData*)user_data;
+	data->func(key, data->user_data);
+}
+
+void
+mono_metadata_generic_class_foreach(MonoGenericClassFunc func, void* user_data)
+{
+	GenericClassForeachData data;
+	guint i;
+
+	data.func = func;
+	data.user_data = user_data;
+
+	for(i = 0; i < HASH_TABLE_SIZE; ++i)
+	{ 
+		MonoImageSet* imageSet = img_set_cache[i];
+
+		if (imageSet == NULL || imageSet->gclass_cache == NULL)
+			continue;
+
+		mono_image_set_lock(imageSet);
+
+		mono_conc_hashtable_foreach(imageSet->gclass_cache, generic_class_foreach_callback, &data);
+
+		mono_image_set_unlock(imageSet);
+	}
+}
+
+void
+mono_metadata_image_set_foreach(MonoImageSetFunc func, gpointer user_data)
+{
+	GenericClassForeachData data;
+	guint i;
+
+	data.func = func;
+	data.user_data = user_data;
+
+	for (i = 0; i < HASH_TABLE_SIZE; ++i)
+	{
+		MonoImageSet* imageSet = img_set_cache[i];
+
+		if (imageSet == NULL)
+			continue;
+
+		mono_image_set_lock(imageSet);
+		func(imageSet, user_data);
+		mono_image_set_unlock(imageSet);
+	}
+}
+
 static gboolean
 _mono_metadata_generic_class_equal (const MonoGenericClass *g1, const MonoGenericClass *g2, gboolean signature_only)
 {

mono/metadata/metadata.h

@@ -332,6 +332,8 @@ typedef enum {
 	MONO_PARSE_FIELD
 } MonoParseTypeMode;
 
+typedef void(*MonoGenericClassFunc) (MonoGenericClass *genericClass, void* user_data);
+
 MONO_API mono_bool
 mono_type_is_byref       (MonoType *type);
 
@@ -426,6 +428,7 @@ MONO_API int            mono_type_stack_size            (MonoType        *type,
 
 MONO_API mono_bool       mono_type_generic_inst_is_valuetype      (MonoType *type);
 MONO_API mono_bool       mono_metadata_generic_class_is_valuetype (MonoGenericClass *gclass);
+MONO_API void            mono_metadata_generic_class_foreach(MonoGenericClassFunc func, void* user_data);
 
 MONO_API unsigned int          mono_metadata_type_hash         (MonoType *t1);
 MONO_API mono_bool       mono_metadata_type_equal        (MonoType *t1, MonoType *t2);