Refactor GC bridge to use UCO callback instead of wait_for_processing

- Pass UCO callback to native during initialization
- Native mark_cross_references calls the UCO callback directly
- UCO stores args in ConcurrentQueue and signals SemaphoreSlim
- C# background thread waits on semaphore and processes from queue
- Remove clr_gc_bridge_wait_for_processing P/Invoke
- Remove semaphore and atomic from C++ code
- Regenerate pinvoke-tables.include

Co-authored-by: simonrozsival <374616+simonrozsival@users.noreply.github.com>

Author: Copilot

src/Mono.Android/Android.Runtime/RuntimeNativeMethods.cs

@@ -86,17 +86,13 @@ internal unsafe static class RuntimeNativeMethods
 		internal static extern bool clr_typemap_java_to_managed (string java_type_name, out IntPtr managed_assembly_name, out uint managed_type_token_id);
 
 		/// <summary>
-		/// Initialize GC bridge for managed processing mode (no native background thread).
+		/// Initialize GC bridge for managed processing mode.
+		/// Takes a callback that will be invoked when mark_cross_references is called by the GC.
 		/// Returns the mark_cross_references function pointer to pass to JavaMarshal.Initialize.
 		/// </summary>
 		[DllImport (RuntimeConstants.InternalDllName, CallingConvention = CallingConvention.Cdecl)]
-		internal static extern delegate* unmanaged<MarkCrossReferencesArgs*, void> clr_gc_bridge_initialize_for_managed_processing ();
-
-		/// <summary>
-		/// Wait for the next set of cross references to process. Blocks until mark_cross_references is called by the GC.
-		/// </summary>
-		[DllImport (RuntimeConstants.InternalDllName, CallingConvention = CallingConvention.Cdecl)]
-		internal static extern MarkCrossReferencesArgs* clr_gc_bridge_wait_for_processing ();
+		internal static extern delegate* unmanaged<MarkCrossReferencesArgs*, void> clr_gc_bridge_initialize_for_managed_processing (
+			delegate* unmanaged[Cdecl]<MarkCrossReferencesArgs*, void> onMarkCrossReferencesCallback);
 
 		/// <summary>
 		/// Trigger Java garbage collection.

src/Mono.Android/Microsoft.Android.Runtime/ManagedValueManager.cs

@@ -28,15 +28,29 @@ class ManagedValueManager : JniRuntime.JniValueManager
 	bool disposed;
 
 	static readonly SemaphoreSlim bridgeProcessingSemaphore = new (1, 1);
+	static readonly SemaphoreSlim pendingArgsSemaphore = new (0, int.MaxValue);
+	static readonly ConcurrentQueue<IntPtr> pendingArgsQueue = new ();
 	static Thread? bridgeProcessingThread;
 
 	static Lazy<ManagedValueManager> s_instance = new (() => new ManagedValueManager ());
 	public static ManagedValueManager GetOrCreateInstance () => s_instance.Value;
 
+	/// <summary>
+	/// UCO callback invoked by native code when mark_cross_references is called.
+	/// This stores the args pointer in a queue and signals the processing thread.
+	/// </summary>
+	[UnmanagedCallersOnly (CallConvs = [typeof (CallConvCdecl)])]
+	static unsafe void OnMarkCrossReferences (MarkCrossReferencesArgs* args)
+	{
+		pendingArgsQueue.Enqueue ((IntPtr)args);
+		pendingArgsSemaphore.Release ();
+	}
+
 	unsafe ManagedValueManager ()
 	{
-		// Initialize GC bridge for managed processing mode (C# background thread instead of C++)
-		var mark_cross_references_ftn = RuntimeNativeMethods.clr_gc_bridge_initialize_for_managed_processing ();
+		// Initialize GC bridge with our UCO callback that will be invoked when mark_cross_references is called
+		delegate* unmanaged[Cdecl]<MarkCrossReferencesArgs*, void> callback = &OnMarkCrossReferences;
+		var mark_cross_references_ftn = RuntimeNativeMethods.clr_gc_bridge_initialize_for_managed_processing (callback);
 		JavaMarshal.Initialize (mark_cross_references_ftn);
 
 		// Start the managed bridge processing thread
@@ -446,11 +460,16 @@ public static void Free (ref HandleContext* context)
 	static unsafe void ManagedBridgeProcessingLoop ()
 	{
 		while (true) {
-			// Wait for mark_cross_references to be called by the GC
-			MarkCrossReferencesArgs* args = RuntimeNativeMethods.clr_gc_bridge_wait_for_processing ();
+			// Wait for OnMarkCrossReferences to be called by the GC via our UCO callback
+			pendingArgsSemaphore.Wait ();
+
+			if (!pendingArgsQueue.TryDequeue (out IntPtr argsPtr)) {
+				throw new InvalidOperationException ("pendingArgsQueue was signaled but no args were available");
+			}
 
+			MarkCrossReferencesArgs* args = (MarkCrossReferencesArgs*)argsPtr;
 			if (args == null) {
-				throw new InvalidOperationException ("clr_gc_bridge_wait_for_processing returned null");
+				throw new InvalidOperationException ("MarkCrossReferencesArgs pointer was null");
 			}
 
 			// Start processing - acquire semaphore and validate contexts

src/native/clr/host/gc-bridge.cc

@@ -52,8 +52,9 @@ void GCBridge::mark_cross_references (MarkCrossReferencesArgs *args) noexcept
 	abort_unless (args->CrossReferences != nullptr || args->CrossReferenceCount == 0, "CrossReferences must not be null if CrossReferenceCount is greater than 0");
 	log_mark_cross_references_args_if_enabled (args);
 
-	shared_args.store (args);
-	shared_args_semaphore.release ();
+	// Invoke the managed callback to queue the args for processing
+	abort_unless (on_mark_cross_references_callback != nullptr, "on_mark_cross_references_callback must be set before mark_cross_references is called");
+	on_mark_cross_references_callback (args);
 }
 
 [[gnu::always_inline]]

src/native/clr/host/internal-pinvokes-shared.cc

@@ -34,14 +34,9 @@ void _monodroid_weak_gref_delete (jobject handle, char type, const char *threadN
 	OSBridge::_monodroid_weak_gref_delete (handle, type, threadName, threadId, from);
 }
 
-BridgeProcessingFtn clr_gc_bridge_initialize_for_managed_processing () noexcept
+BridgeProcessingFtn clr_gc_bridge_initialize_for_managed_processing (OnMarkCrossReferencesCallback callback) noexcept
 {
-	return GCBridge::initialize_for_managed_processing ();
-}
-
-MarkCrossReferencesArgs* clr_gc_bridge_wait_for_processing () noexcept
-{
-	return GCBridge::wait_for_processing ();
+	return GCBridge::initialize_for_managed_processing (callback);
 }
 
 void clr_gc_bridge_trigger_java_gc () noexcept

src/native/clr/include/host/gc-bridge.hh

@@ -1,8 +1,6 @@
 #pragma once
 
-#include <atomic>
 #include <jni.h>
-#include <semaphore>
 
 #include <shared/cpp-util.hh>
 #include <host/os-bridge.hh>
@@ -48,6 +46,7 @@ struct MarkCrossReferencesArgs
 };
 
 using BridgeProcessingFtn = void (*)(MarkCrossReferencesArgs*);
+using OnMarkCrossReferencesCallback = void (*)(MarkCrossReferencesArgs*);
 
 namespace xamarin::android {
 	class GCBridge
@@ -56,22 +55,16 @@ namespace xamarin::android {
 		static void initialize_on_onload (JNIEnv *env) noexcept;
 		static void initialize_on_runtime_init (JNIEnv *env, jclass runtimeClass) noexcept;
 
+		// Initialize GC bridge for managed processing mode.
+		// Takes a callback that will be invoked when mark_cross_references is called by the GC.
+		// The callback is expected to queue the args and signal a managed thread to process them.
 		// Returns the mark_cross_references function pointer for JavaMarshal.Initialize.
-		// All GC bridge processing is done in managed code (C#).
-		// This function just provides the callback pointer for the GC to invoke.
-		static BridgeProcessingFtn initialize_for_managed_processing () noexcept
+		static BridgeProcessingFtn initialize_for_managed_processing (OnMarkCrossReferencesCallback callback) noexcept
 		{
+			on_mark_cross_references_callback = callback;
 			return mark_cross_references;
 		}
 
-		// Wait for the next set of cross references to process (for managed processing mode)
-		// Blocks until mark_cross_references is called by the GC
-		static MarkCrossReferencesArgs* wait_for_processing () noexcept
-		{
-			shared_args_semaphore.acquire ();
-			return shared_args.load ();
-		}
-
 		static void trigger_java_gc (JNIEnv *env) noexcept;
 
 		// Trigger Java GC using the cached Runtime instance (for managed processing mode)
@@ -82,8 +75,7 @@ namespace xamarin::android {
 		}
 
 	private:
-		static inline std::binary_semaphore shared_args_semaphore{0};
-		static inline std::atomic<MarkCrossReferencesArgs*> shared_args;
+		static inline OnMarkCrossReferencesCallback on_mark_cross_references_callback = nullptr;
 
 		static inline jobject Runtime_instance = nullptr;
 		static inline jmethodID Runtime_gc = nullptr;

src/native/clr/include/runtime-base/internal-pinvokes.hh

@@ -17,8 +17,7 @@ extern "C" {
 	bool clr_typemap_java_to_managed (const char *java_type_name, char const** assembly_name, uint32_t *managed_type_token_id) noexcept;
 
 	// Functions for managed GC bridge processing mode
-	BridgeProcessingFtn clr_gc_bridge_initialize_for_managed_processing () noexcept;
-	MarkCrossReferencesArgs* clr_gc_bridge_wait_for_processing () noexcept;
+	BridgeProcessingFtn clr_gc_bridge_initialize_for_managed_processing (OnMarkCrossReferencesCallback callback) noexcept;
 	void clr_gc_bridge_trigger_java_gc () noexcept;
 
 	void monodroid_log (xamarin::android::LogLevel level, LogCategories category, const char *message) noexcept;

src/native/clr/pinvoke-override/generate-pinvoke-tables.cc

@@ -70,7 +70,6 @@ const std::vector<std::string> internal_pinvoke_names = {
 	"clr_typemap_managed_to_java",
 	"clr_typemap_java_to_managed",
 	"clr_gc_bridge_initialize_for_managed_processing",
-	"clr_gc_bridge_wait_for_processing",
 	"clr_gc_bridge_trigger_java_gc",
 	"_monodroid_weak_gref_delete",
 	"_monodroid_weak_gref_get",

src/native/clr/pinvoke-override/pinvoke-tables.include

@@ -11,7 +11,7 @@
 namespace {
 #if INTPTR_MAX == INT64_MAX
 	//64-bit internal p/invoke table
-	std::array<PinvokeEntry, 26> internal_pinvokes {{
+	std::array<PinvokeEntry, 25> internal_pinvokes {{
 		{0x34f89602cc44d0, "clr_gc_bridge_initialize_for_managed_processing", reinterpret_cast<void*>(&clr_gc_bridge_initialize_for_managed_processing)},
 		{0x3b2467e7eadd4a6a, "_monodroid_lref_log_new", reinterpret_cast<void*>(&_monodroid_lref_log_new)},
 		{0x423c8f539a2c56d2, "_monodroid_lookup_replacement_type", reinterpret_cast<void*>(&_monodroid_lookup_replacement_type)},
@@ -20,7 +20,6 @@ namespace {
 		{0x5f0b4e426eff086b, "_monodroid_detect_cpu_and_architecture", reinterpret_cast<void*>(&_monodroid_detect_cpu_and_architecture)},
 		{0x9099a4b95e3c3a89, "_monodroid_lref_log_delete", reinterpret_cast<void*>(&_monodroid_lref_log_delete)},
 		{0x9187e6bc6294cacf, "clr_typemap_managed_to_java", reinterpret_cast<void*>(&clr_typemap_managed_to_java)},
-		{0x9857d0d4f620e7d2, "clr_gc_bridge_wait_for_processing", reinterpret_cast<void*>(&clr_gc_bridge_wait_for_processing)},
 		{0x9a946dfe9916a942, "clr_typemap_java_to_managed", reinterpret_cast<void*>(&clr_typemap_java_to_managed)},
 		{0xa6ec846592d99536, "_monodroid_weak_gref_delete", reinterpret_cast<void*>(&_monodroid_weak_gref_delete)},
 		{0xa7f58f3ee428cc6b, "_monodroid_gref_log_delete", reinterpret_cast<void*>(&_monodroid_gref_log_delete)},
@@ -545,8 +544,7 @@ constexpr hash_t system_security_cryptography_native_android_library_hash = 0x18
 constexpr hash_t system_globalization_native_library_hash = 0x28b5c8fca080abd5;
 #else
 	//32-bit internal p/invoke table
-	std::array<PinvokeEntry, 26> internal_pinvokes {{
-		{0x6ba8719, "clr_gc_bridge_wait_for_processing", reinterpret_cast<void*>(&clr_gc_bridge_wait_for_processing)},
+	std::array<PinvokeEntry, 25> internal_pinvokes {{
 		{0xb7a486a, "monodroid_TypeManager_get_java_class_name", reinterpret_cast<void*>(&monodroid_TypeManager_get_java_class_name)},
 		{0x1d6638a0, "clr_gc_bridge_initialize_for_managed_processing", reinterpret_cast<void*>(&clr_gc_bridge_initialize_for_managed_processing)},
 		{0x21bee2a0, "clr_gc_bridge_trigger_java_gc", reinterpret_cast<void*>(&clr_gc_bridge_trigger_java_gc)},
@@ -1079,6 +1077,6 @@ constexpr hash_t system_security_cryptography_native_android_library_hash = 0x93
 constexpr hash_t system_globalization_native_library_hash = 0xa66f1e5a;
 #endif
 
-constexpr size_t internal_pinvokes_count = 26;
+constexpr size_t internal_pinvokes_count = 25;
 constexpr size_t dotnet_pinvokes_count = 491;
 } // end of anonymous namespace