Add basic late handles support.

Author: joncham

mono/metadata/boehm-gc.c

@@ -63,7 +63,8 @@ static gboolean gc_strict_wbarriers = FALSE;
 static mono_mutex_t mono_gc_lock;
 
 static GC_push_other_roots_proc default_push_other_roots;
-static GHashTable *roots;
+static GHashTable* roots;
+static GHashTable* late_handles;
 
 typedef struct ephemeron_node ephemeron_node;
 static ephemeron_node* ephemeron_list;
@@ -122,12 +123,12 @@ struct HandleData {
 	gpointer  entries[HANDLE_COUNT];
 };
 
-#define GC_HANDLE_TYPE_IS_WEAK(x) ((x) <= HANDLE_WEAK_TRACK)
+#define GC_HANDLE_TYPE_IS_WEAK(x) (((x) == HANDLE_WEAK) ||((x) == HANDLE_WEAK_TRACK) ||((x) == HANDLE_WEAK_FIELDS))
 
-#define MONO_GC_HANDLE_TYPE_IS_WEAK(x) ((x) <= HANDLE_WEAK_TRACK)
+#define MONO_GC_HANDLE_TYPE_IS_WEAK(x) (((x) == HANDLE_WEAK) ||((x) == HANDLE_WEAK_TRACK) ||((x) == HANDLE_WEAK_FIELDS))
 
-static HandleData* gc_handles[4];
-static HandleData* gc_handles_free[4];
+static HandleData* gc_handles[HANDLE_TYPE_MAX];
+static HandleData* gc_handles_free[HANDLE_TYPE_MAX];
 
 static void
 mono_gc_warning (char *msg, GC_word arg)
@@ -202,6 +203,7 @@ mono_gc_base_init (void)
 #endif
 
 	roots = g_hash_table_new (NULL, NULL);
+	late_handles = g_hash_table_new(NULL, NULL);
 	default_push_other_roots = GC_get_push_other_roots ();
 	GC_set_push_other_roots (mono_push_other_roots);
 	GC_set_mark_stack_empty (mono_push_ephemerons);
@@ -702,6 +704,30 @@ mono_gc_register_root (char *start, size_t size, void *descr, MonoGCRootSource s
 	return TRUE;
 }
 
+typedef struct {
+	gpointer *start;
+	size_t count;
+} LateHandleData;
+
+static gpointer
+register_late_handles(gpointer arg)
+{
+	RootData* root_data = (RootData*)arg;
+	g_hash_table_insert(late_handles, root_data->start, root_data->end);
+	return NULL;
+}
+
+int
+mono_gc_register_late_handles(gpointer* start, size_t count)
+{
+	LateHandleData root_data;
+	root_data.start = start;
+	root_data.count = count;
+	GC_call_with_alloc_lock(register_late_handles, &root_data);
+	//MONO_PROFILER_RAISE(gc_root_register, ((const mono_byte*)start, size, source, key, msg));
+	return TRUE;
+}
+
 int
 mono_gc_register_root_wbarrier (char *start, size_t size, MonoGCDescriptor descr, MonoGCRootSource source, void *key, const char *msg)
 {
@@ -1652,7 +1678,10 @@ handle_data_alloc_entries(int type)
 	if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
 		handles->domain_ids = (guint16 *)g_malloc0 (sizeof (*handles->domain_ids) * handles->size);
 	} else {
-		mono_gc_register_root((char*) &handles->entries[0], HANDLE_COUNT * sizeof(gpointer), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_GC_HANDLE, NULL, "GC Handle Data");
+		if (handles->type == HANDLE_LATE)
+			mono_gc_register_late_handles(&handles->entries[0], HANDLE_COUNT);
+		else
+			mono_gc_register_root((char*) &handles->entries[0], HANDLE_COUNT * sizeof(gpointer), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_GC_HANDLE, NULL, "GC Handle Data");
 	}
 	handles->bitmap = (guint32 *)g_malloc0 (handles->size / CHAR_BIT);
 
@@ -1801,6 +1830,12 @@ mono_gchandle_new_internal (MonoObject *obj, gboolean pinned)
 	return alloc_handle (pinned? HANDLE_PINNED: HANDLE_NORMAL, obj, FALSE);
 }
 
+MonoGCHandle
+mono_gchandle_new_late_internal(MonoObject* obj)
+{
+	return alloc_handle(HANDLE_LATE, obj, FALSE);
+}
+
 /**
  * mono_gchandle_new_weakref_internal:
  * \param obj managed object to get a handle for
@@ -2036,7 +2071,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_TYPE_MAX; ++type) {
 		guint slot;
 		HandleData *handles = gc_handles [type];
 		lock_handles (handles);
@@ -2162,6 +2197,37 @@ mono_clear_ephemerons (void)
 static struct GC_ms_entry*
 mono_push_ephemerons (struct GC_ms_entry* mark_stack_ptr, struct GC_ms_entry* mark_stack_limit)
 {
+	/* push late GC handles */
+	{
+		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 = handles + i;
+				if (!*handle)
+					continue;
+
+				MonoObject* object = *handle;
+
+				if (GC_is_marked(object)) {
+					continue;
+				}
+				else {
+
+					mark_stack_ptr = GC_mark_and_push(object, mark_stack_ptr, mark_stack_limit, handle);
+				}
+			}
+		}
+	}
+
+
 	ephemeron_node* prev_node = NULL;
 	ephemeron_node* current_node = NULL;
 
@@ -2257,8 +2323,10 @@ mono_gc_strong_handle_foreach(GFunc func, gpointer user_data)
 
 	lock_handles(handles);
 
-	for (gcHandleTypeIndex = HANDLE_NORMAL; gcHandleTypeIndex <= HANDLE_PINNED; gcHandleTypeIndex++)
+	for (gcHandleTypeIndex = HANDLE_TYPE_MIN; gcHandleTypeIndex < HANDLE_TYPE_MAX; gcHandleTypeIndex++)
 	{
+		if (GC_HANDLE_TYPE_IS_WEAK(gcHandleTypeIndex))
+			continue;
 		HandleData* handles = gc_handles[gcHandleTypeIndex];
 
 		while (handles != NULL) {

mono/metadata/external-only.c

@@ -51,6 +51,12 @@ mono_gchandle_new_v2 (MonoObject *obj, mono_bool pinned)
 	MONO_EXTERNAL_ONLY_GC_UNSAFE (MonoGCHandle, mono_gchandle_new_internal (obj, pinned));
 }
 
+MonoGCHandle
+mono_gchandle_new_late_v2(MonoObject* obj)
+{
+	MONO_EXTERNAL_ONLY_GC_UNSAFE(MonoGCHandle, mono_gchandle_new_late_internal(obj));
+}
+
 /**
  * mono_gchandle_new_weakref:
  * \param obj managed object to get a handle for

mono/metadata/object-internals.h

@@ -2372,6 +2372,9 @@ mono_runtime_get_aotid_arr (void);
 MonoGCHandle
 mono_gchandle_new_internal (MonoObject *obj, mono_bool pinned);
 
+MonoGCHandle
+mono_gchandle_new_late_internal(MonoObject* obj);
+
 MonoGCHandle
 mono_gchandle_new_weakref_internal (MonoObject *obj, mono_bool track_resurrection);
 

mono/metadata/object.h

@@ -376,6 +376,7 @@ MONO_API MONO_RT_EXTERNAL_ONLY void         mono_gchandle_free        (uint32_t
 UNITY_MONO_API MONO_RT_EXTERNAL_ONLY mono_bool mono_gchandle_is_in_domain (uint32_t gchandle, MonoDomain* domain);
 
 MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_v2         (MonoObject *obj, mono_bool pinned);
+MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_late_v2    (MonoObject *obj);
 MONO_API MONO_RT_EXTERNAL_ONLY MonoGCHandle mono_gchandle_new_weakref_v2 (MonoObject *obj, mono_bool track_resurrection);
 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);

mono/sgen/gc-internal-agnostic.h

@@ -53,6 +53,7 @@ typedef enum {
 	HANDLE_NORMAL,
 	HANDLE_PINNED,
 	HANDLE_WEAK_FIELDS,
+	HANDLE_LATE,
 	HANDLE_TYPE_MAX
 } GCHandleType;