Basic functionality working.

Author: joncham

mono/metadata/boehm-gc.c

@@ -69,6 +69,13 @@ static GHashTable* late_handles;
 typedef struct ephemeron_node ephemeron_node;
 static ephemeron_node* ephemeron_list;
 
+static OnThreadsSuspendedCallback s_on_threads_suspended;
+static void* s_on_threads_suspended_arg;
+static OnHandleFoundCallback s_on_handle_found;
+static void* s_on_handle_found_arg;
+static OnProcessCallback s_on_process;
+static void* s_on_process_arg;
+
 static void
 mono_push_other_roots(void);
 
@@ -583,6 +590,8 @@ on_gc_notification (GC_EventType event)
 	case GC_EVENT_POST_STOP_WORLD:
 		e = MONO_GC_EVENT_POST_STOP_WORLD;
 		MONO_GC_WORLD_STOP_END ();
+		if (s_on_threads_suspended)
+			s_on_threads_suspended(s_on_threads_suspended_arg);
 		break;
 
 	case GC_EVENT_PRE_START_WORLD:
@@ -2194,10 +2203,52 @@ mono_clear_ephemerons (void)
 	}
 }
 
+//LateHandleCallback s_late_handle_callback;
+//void* s_late_handle_callback_user_data;
+
+
+
+void
+mono_gc_collect_assets(
+	OnThreadsSuspendedCallback on_threads_suspended, void* on_threads_suspended_arg,
+	OnHandleFoundCallback on_handle_found, void* on_handle_found_arg,
+	OnProcessCallback on_process, void* on_process_arg)
+{
+	s_on_threads_suspended = on_threads_suspended;
+	s_on_threads_suspended_arg = on_threads_suspended_arg;
+	s_on_handle_found = on_handle_found;
+	s_on_handle_found_arg = on_handle_found_arg;
+	s_on_process = on_process;
+	s_on_process_arg = on_process_arg;
+	mono_gc_collect(mono_gc_max_generation());
+	s_on_threads_suspended = NULL;
+	s_on_threads_suspended_arg = NULL;
+	s_on_handle_found = NULL;
+	s_on_handle_found_arg = NULL;
+	s_on_process = NULL;
+	s_on_process_arg = NULL;
+}
+
+typedef struct {
+	struct GC_ms_entry* mark_stack_ptr;
+	struct GC_ms_entry* mark_stack_limit;
+} MarkHandleData;
+
+MarkHandleData* s_mark_data;
+
+
+void mono_gchandle_mark_object(MonoObject* obj)
+{
+	g_assert(s_mark_data);
+	s_mark_data->mark_stack_ptr = GC_mark_and_push(obj, s_mark_data->mark_stack_ptr, s_mark_data->mark_stack_limit, NULL);
+}
+
 static struct GC_ms_entry*
 mono_push_ephemerons (struct GC_ms_entry* mark_stack_ptr, struct GC_ms_entry* mark_stack_limit)
 {
+	struct GC_ms_entry* mark_stack_ptr_orig = mark_stack_ptr;
 	/* push late GC handles */
+	if (s_on_handle_found)
 	{
 		GHashTableIter iter;
 		g_hash_table_iter_init(&iter, late_handles);
@@ -2210,23 +2261,67 @@ mono_push_ephemerons (struct GC_ms_entry* mark_stack_ptr, struct GC_ms_entry* ma
 			gpointer* handles = key;
 			size_t length = (size_t)value;
 			for (size_t i = 0; i < length; ++i) {
-				MonoObject** handle = handles + i;
-				if (!*handle)
+				MonoObject** handle = (MonoObject**)(handles + i);
+				MonoObject* object = *handle;
+
+				if (!object)
 					continue;
 
-				MonoObject* object = *handle;
+				/* avoid objects we've already processed before */
+				if ((size_t)object & 1)
+					continue;
 
 				if (GC_is_marked(object)) {
-					continue;
-				}
-				else {
+					s_on_handle_found(s_on_handle_found_arg, object);
 
-					mark_stack_ptr = GC_mark_and_push(object, mark_stack_ptr, mark_stack_limit, handle);
+					*handle = (MonoObject*)((size_t)object | 1);
 				}
 			}
 		}
 	}
 
+	/* callback to allow client to process a batch of handles */
+	if (s_on_process) {
+		MarkHandleData data;
+		data.mark_stack_ptr = mark_stack_ptr;
+		data.mark_stack_limit = mark_stack_limit;
+		s_mark_data = &data;
+		s_on_process(s_on_process_arg);
+		mark_stack_ptr = data.mark_stack_ptr;
+		s_mark_data = NULL;
+	}
+
+	/* mark all handles, as we want to keep all targets alive like a strong handle */
+	if (mark_stack_ptr_orig == mark_stack_ptr) {
+		GHashTableIter iter;
+		g_hash_table_iter_init(&iter, late_handles);
+
+		gpointer key;
+		gpointer value;
+
+		while (g_hash_table_iter_next(&iter, &key, &value)) {
+			/* process handles */
+			gpointer* handles = key;
+			size_t length = (size_t)value;
+			for (size_t i = 0; i < length; ++i) {
+				MonoObject** handle = (MonoObject**)(handles + i);
+
+				/* remove the bit we set to indicate processing */
+				if ((size_t)*handle & 1)
+					*handle = (MonoObject*)((size_t)*handle & ~(size_t)1);
+
+				MonoObject* object = *handle;
+				if (!object)
+					continue;
+
+				mark_stack_ptr = GC_mark_and_push(object, mark_stack_ptr, mark_stack_limit, handle);
+			}
+		}
+		s_on_handle_found = NULL;
+		s_on_process = NULL;
+		s_on_threads_suspended = NULL;
+	}
+
 
 	ephemeron_node* prev_node = NULL;
 	ephemeron_node* current_node = NULL;

mono/metadata/object.h

@@ -381,6 +381,20 @@ MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_weakref_v2 (MonoOb
 MONO_API MONO_RT_EXTERNAL_ONLY MonoObject*  mono_gchandle_get_target_v2  (MonoGCHandle gchandle);
 MONO_API MONO_RT_EXTERNAL_ONLY void         mono_gchandle_free_v2        (MonoGCHandle gchandle);
 
+
+typedef void (*DoUnityProcessing)(void* handle);
+typedef void (*LateHandleCallback)(MonoObject* obj, void* user_data);
+
+typedef void (*OnThreadsSuspendedCallback)(void* arg);
+typedef void (*OnHandleFoundCallback)(void* arg, void* handle);
+typedef void (*OnProcessCallback)(void* arg);
+MONO_API MONO_RT_EXTERNAL_ONLY void mono_gc_collect_assets(
+	OnThreadsSuspendedCallback onThreadsSuspended, void* onThreadsSuspendedArg,
+	OnHandleFoundCallback onHandleFound, void* onHandleFoundArg,
+	OnProcessCallback onProcess, void* onProcessArg);
+
+MONO_API MONO_RT_EXTERNAL_ONLY void mono_gchandle_mark_object(MonoObject* obj);
+
 /* make sure the gchandle was allocated for an object in domain */
 UNITY_MONO_API MONO_RT_EXTERNAL_ONLY mono_bool mono_gchandle_is_in_domain_v2 (MonoGCHandle gchandle, MonoDomain* domain);
 

mono/metadata/sgen-mono.c

@@ -2781,6 +2781,13 @@ mono_gchandle_new_internal (MonoObject *obj, gboolean pinned)
 	return MONO_GC_HANDLE_FROM_UINT (sgen_gchandle_new (obj, pinned));
 }
 
+MonoGCHandle
+mono_gchandle_new_late_internal(MonoObject* obj)
+{
+	g_assert_not_reached ();
+	return 0;
+}
+
 /**
  * mono_gchandle_new_weakref_internal:
  * \param obj managed object to get a handle for