Avoid redundant Java GC bridge graph computation (dotnet#131764)

On Android the GC bridge hands a set of cross references to the client
on every collection that finds at least one dead Java peer. The client
answers each of those with an explicit ART collection, and while that
runs the UI thread blocks creating JNI global references, which shows up
as dropped frames.

This skips the SCC computation when it is known to be discarded. The VM
already frees the `MarkCrossReferencesArgs` without forwarding them when
the client is still processing a previous set, so the Tarjan pass and
the allocations feeding it were pure waste. The GC can now ask the
client first via the new `IGCToCLR::IsClientBridgeProcessingActive`, and
skips the work instead. This is behavior neutral: every registered
bridge object is promoted whether or not the cross references were
computed, so skipping only delays reporting a dead peer, it never
collects one early.

Adding a method to `IGCToCLR` is a breaking interface change, so
`EE_INTERFACE_MAJOR_VERSION` goes from 4 to 5.

Part of the investigation in dotnet#131370.

Scoped down from the original version of this PR at @BrzVlad's request —
the timing heuristic that was bundled here has been removed and is not
part of this change.

### Validation

Built `clr` clean (0 errors, 0 warnings) for:
- `android-arm64` Release — the configuration where
`FEATURE_JAVAMARSHAL` is on by default
- `osx-arm64` Checked — non-Android, `FEATURE_JAVAMARSHAL` also on,
covers the interface plumbing outside Android

`gcbridge.cpp` was confirmed compiled into both the CoreCLR VM and the
NativeAOT workstation/server GC objects. The standalone GC sample under
`src/coreclr/gc/sample` is not part of either build and was not
compiled.

> [!NOTE]
> Portions of this pull request description were generated with GitHub
Copilot.

---------

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 91dd8b98-73db-41b0-8d8c-9e1c21b53f5f

Author: 2 people

src/coreclr/gc/env/gcenv.ee.h

@@ -41,6 +41,8 @@ class GCToEEInterface
 
     static void TriggerClientBridgeProcessing(MarkCrossReferencesArgs* args);
 
+    static bool IsClientBridgeProcessingActive();
+
     // Sync block cache management
     static void SyncBlockCacheWeakPtrScan(HANDLESCANPROC scanProc, uintptr_t lp1, uintptr_t lp2);
     static void SyncBlockCacheDemote(int max_gen);

src/coreclr/gc/env/gctoeeinterface.standalone.inl

@@ -54,6 +54,11 @@ namespace standalone
             return ::GCToEEInterface::TriggerClientBridgeProcessing(args);
         }
 
+        bool IsClientBridgeProcessingActive()
+        {
+            return ::GCToEEInterface::IsClientBridgeProcessingActive();
+        }
+
         void SyncBlockCacheWeakPtrScan(HANDLESCANPROC scanProc, uintptr_t lp1, uintptr_t lp2)
         {
             ::GCToEEInterface::SyncBlockCacheWeakPtrScan(scanProc, lp1, lp2);

src/coreclr/gc/gcbridge.cpp

@@ -1111,6 +1111,13 @@ uint8_t** GetRegisteredBridges(size_t* pNumBridges)
     return (uint8_t**)g_registeredBridges.data;
 }
 
+bool ShouldProcessBridgeObjects()
+{
+    // The client discards any set of cross references handed to it while it is still
+    // processing a previous one, so computing it would be pure waste.
+    return !GCToEEInterface::IsClientBridgeProcessingActive();
+}
+
 static bool TarjanSccAlgorithm()
 {
     int i;

src/coreclr/gc/gcbridge.h

@@ -12,6 +12,11 @@
 void BridgeResetData();
 MarkCrossReferencesArgs* ProcessBridgeObjects();
 
+// Decides whether this collection should hand a fresh set of cross references to the client.
+// Returns false when the client is still processing a previous set, since the new one would
+// just be discarded.
+bool ShouldProcessBridgeObjects();
+
 void RegisterBridgeObject(Object *object, uintptr_t context);
 uint8_t** GetRegisteredBridges(size_t *pNumBridges);
 

src/coreclr/gc/gcenv.ee.standalone.inl

@@ -81,6 +81,17 @@ inline void GCToEEInterface::TriggerClientBridgeProcessing(MarkCrossReferencesAr
     }
 }
 
+inline bool GCToEEInterface::IsClientBridgeProcessingActive()
+{
+    assert(g_theGCToCLR != nullptr);
+    if (g_runtimeSupportedVersion.MajorVersion >= 5)
+    {
+        return g_theGCToCLR->IsClientBridgeProcessingActive();
+    }
+
+    return false;
+}
+
 inline void GCToEEInterface::SyncBlockCacheWeakPtrScan(HANDLESCANPROC scanProc, uintptr_t lp1, uintptr_t lp2)
 {
     assert(g_theGCToCLR != nullptr);

src/coreclr/gc/gcinterface.ee.h

@@ -467,6 +467,14 @@ class IGCToCLR {
 
     virtual
     void TriggerClientBridgeProcessing(MarkCrossReferencesArgs* args) PURE_VIRTUAL
+
+    // The following method is available only with EE_INTERFACE_MAJOR_VERSION >= 5
+
+    // Returns true when the client is still processing cross references handed to it by a
+    // previous call to TriggerClientBridgeProcessing. While that is the case any new set of
+    // cross references would be discarded by the client, so the GC can skip computing it.
+    virtual
+    bool IsClientBridgeProcessingActive() PURE_VIRTUAL
 };
 
 #endif // _GCINTERFACE_EE_H_

src/coreclr/gc/gcinterface.h

@@ -15,7 +15,7 @@
 
 // The major version of the IGCToCLR interface. Breaking changes to this interface
 // require bumps in the major version number.
-#define EE_INTERFACE_MAJOR_VERSION 4
+#define EE_INTERFACE_MAJOR_VERSION 5
 
 struct ScanContext;
 struct gc_alloc_context;

src/coreclr/gc/objecthandle.cpp

@@ -1535,13 +1535,19 @@ uint8_t** Ref_ScanBridgeObjects(uint32_t condemned, uint32_t maxgen, ScanContext
     }
 
     // The callee here will free the allocated memory.
-    MarkCrossReferencesArgs *args = ProcessBridgeObjects();
-
-    if (args != NULL)
+    if (ShouldProcessBridgeObjects())
     {
-        GCToEEInterface::TriggerClientBridgeProcessing(args);
+        MarkCrossReferencesArgs *args = ProcessBridgeObjects();
+
+        if (args != NULL)
+        {
+            GCToEEInterface::TriggerClientBridgeProcessing(args);
+        }
     }
 
+    // Every registered bridge object is promoted whether or not the cross references were
+    // computed above, so skipping the work while the client is busy only delays reporting a
+    // dead peer, it never collects one early.
     return GetRegisteredBridges(numObjs);
 }
 #endif // FEATURE_JAVAMARSHAL

src/coreclr/gc/sample/gcenv.ee.cpp

@@ -168,6 +168,11 @@ void GCToEEInterface::TriggerClientBridgeProcessing(MarkCrossReferencesArgs* arg
 {
 }
 
+bool GCToEEInterface::IsClientBridgeProcessingActive()
+{
+    return false;
+}
+
 bool GCToEEInterface::IsPreemptiveGCDisabled()
 {
     Thread* pThread = ::GetThread();

src/coreclr/nativeaot/Runtime/gcenv.ee.cpp

@@ -826,4 +826,13 @@ void GCToEEInterface::TriggerClientBridgeProcessing(MarkCrossReferencesArgs* arg
 #endif
 }
 
+bool GCToEEInterface::IsClientBridgeProcessingActive()
+{
+#ifdef FEATURE_JAVAMARSHAL
+    return JavaMarshalNative::IsGCBridgeActive();
+#else
+    return false;
+#endif
+}
+
 #endif // !DACCESS_COMPILE