Merge pull request #261 from winnerspiros/copilot/fix-black-screen-crash-again

Android: tame Mono worker-thread priority to fix cold-start ANR

Author: winnerspiros

osu.Android/AndroidNativeBridgeManager.cs

@@ -131,6 +131,37 @@ public static int GetBigCoreMask()
             catch { return 0; }
         }
 
+        /// <summary>
+        /// Demotes non-game worker threads (Mono threadpool workers, OkHttp,
+        /// Okio, .NET threadpool, generic "Thread-N") from <c>nice=-10</c>
+        /// down to <c>nice=0</c> and — if <paramref name="littleCoreMask"/>
+        /// is non-zero — pins them to the given LITTLE-core subset.
+        /// </summary>
+        /// <remarks>
+        /// Counter-measure for the Android cold-start black-screen /
+        /// MotionEvent ANR observed on v177: Mono maps
+        /// <c>ThreadPriority.Highest</c> to <c>nice=-10</c>, which is
+        /// Android's display-compositor priority class. Field tombstones
+        /// show Veldrid's shader-compile worker stuck in
+        /// <c>glslang::SetupBuiltinSymbolTable</c> at that priority on a
+        /// big core while the Draw thread is draining a 300+-item
+        /// texture-upload queue — together starving the Android main UI
+        /// thread of CPU bandwidth past the 10s input-dispatch deadline.
+        ///
+        /// Game-loop threads (Update/Draw/Audio/Input), the Android main
+        /// UI thread, and known-critical ART / Android daemons are
+        /// explicitly left alone by the native implementation. Idempotent
+        /// and safe to call repeatedly; returns the number of threads
+        /// whose scheduling was actually mutated for diagnostic logging.
+        /// Returns 0 on any failure (e.g. library not loaded).
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static int TameBackgroundThreads(int littleCoreMask)
+        {
+            try { return OboeAudioBridge.nTameBackgroundThreads(littleCoreMask); }
+            catch { return 0; }
+        }
+
         [MethodImpl(MethodImplOptions.NoInlining)]
         public bool IsOboeActive() => (oboeBridge as OboeAudioBridge)?.IsActive ?? false;
 

osu.Android/Native/OboeAudioBridge.cs

@@ -211,6 +211,7 @@ public void Dispose()
         [DllImport(lib_name)] private static extern IntPtr nOboeGetLastErrorMessage(IntPtr ptr);
         [DllImport(lib_name)] internal static extern byte nSetThreadAffinity(int coreMask);
         [DllImport(lib_name)] internal static extern int nGetBigCoreMask();
+        [DllImport(lib_name)] internal static extern int nTameBackgroundThreads(int littleCoreMask);
         [DllImport(lib_name)] internal static extern IntPtr nADPFCreateSession(long targetDurationNanos);
         [DllImport(lib_name)] internal static extern void nADPFReportActualDuration(IntPtr sessionPtr, long actualDurationNanos);
         [DllImport(lib_name)] internal static extern void nADPFUpdateTargetDuration(IntPtr sessionPtr, long targetDurationNanos);

osu.Android/Native/oboe_bridge.cpp

@@ -7,10 +7,15 @@
 #include <sched.h>
 #include <unistd.h>
 #include <sys/syscall.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <fcntl.h>
 #include <android/log.h>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#include <cstdlib>
 #include <vector>
 #include <algorithm>
 typedef uint8_t byte;
@@ -545,6 +550,144 @@ OSU_EXPORT int nGetBigCoreMask() {
     }
     return mask;
 }
+
+// ============================================================
+// Background-thread taming (field-crash mitigation — see below)
+// ============================================================
+// Android cold-start black-screen / MotionEvent ANR (v177) was root-caused to
+// Veldrid's shader-compile worker running glslang::TPpContext::tokenize deep
+// inside glslang::SetupBuiltinSymbolTable at nice=-10 on a big core, starving
+// the Android main UI thread of CPU at the same moment the Draw thread is
+// draining a 300+-item texture-upload queue. Mono maps .NET
+// ThreadPriority.Highest to nice=-10 for every worker thread it spawns
+// (shader compile, finalizer, network, etc.), which is the display-
+// compositor priority class — inappropriate for CPU-heavy background work.
+//
+// This function walks /proc/self/task, reads each thread's kernel comm, and
+// for any comm matching the Mono-threadpool-worker naming pattern drops the
+// nice value to 0 and (if little_core_mask != 0) pins the thread to the
+// given LITTLE-core subset. Game-loop threads (Update/Draw/Audio/Input), the
+// Android main UI thread (tid == tgid), the calling thread, and a small
+// list of critical ART/system daemons are explicitly left alone.
+//
+// Safe to call repeatedly; subsequent calls are idempotent. Cross-thread
+// setpriority / sched_setaffinity within the same process is allowed for a
+// same-euid caller without CAP_SYS_NICE, so no root required.
+//
+// Returns: number of threads demoted (for diagnostic logging).
+static bool isCommToLeaveAlone(const char* comm) {
+    if (!comm || !*comm) return false;
+
+    // Game-loop threads created by osu-framework GameThread. These MUST stay
+    // at their elevated priority so the render/update/audio/input pipelines
+    // aren't starved by Android's scheduler during play.
+    static const char* const keep[] = {
+        "Update",       "Draw",        "Audio",        "Input",
+        "SDLActivity",  "HangWatchdog",
+        // Known-critical ART / Android daemons; leave to platform defaults.
+        "FinalizerDae", "FinalizerWat", "ReferenceQueu", "HeapTaskDaemo",
+        "Signal Catche", "Jit thread po", "Profile Saver", "binder:",
+        "perfetto",     "main",
+        // Oboe / AAudio callback threads (priority-critical for audio).
+        "AAudio",       "OboeAudio",
+    };
+
+    for (const char* p : keep) {
+        if (std::strncmp(comm, p, std::strlen(p)) == 0)
+            return true;
+    }
+
+    return false;
+}
+
+static bool isCommToDemote(const char* comm) {
+    if (!comm) return false;
+
+    // Empty comm (unnamed thread) — definitely safe to demote; these are
+    // ad-hoc pthread_create workers that inherited nice=-10 from a parent.
+    if (*comm == '\0') return true;
+
+    // Mono threadpool worker default name: "Thread-<n>". This is the thread
+    // that was stuck in glslang::SetupBuiltinSymbolTable in the field
+    // tombstone; it's also used for network / shader / JIT helpers.
+    if (std::strncmp(comm, "Thread-", 7) == 0) return true;
+
+    // OkHttp / Okio network threads — nice=-8 observed in tombstones, no
+    // reason to outrank the main UI thread during cold start.
+    if (std::strncmp(comm, "OkHttp",     6) == 0) return true;
+    if (std::strncmp(comm, "Okio",       4) == 0) return true;
+
+    // .NET threadpool default pattern ("pool-", ".NET Thread", "TP").
+    if (std::strncmp(comm, "pool-",      5) == 0) return true;
+    if (std::strncmp(comm, ".NET",       4) == 0) return true;
+
+    return false;
+}
+
+OSU_EXPORT int nTameBackgroundThreads(int little_core_mask) {
+    DIR* dir = opendir("/proc/self/task");
+    if (!dir) return 0;
+
+    const pid_t self_tid = (pid_t)syscall(SYS_gettid);
+    const pid_t tgid = getpid();
+
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    bool haveCpuset = false;
+    if (little_core_mask != 0) {
+        for (int i = 0; i < 32; i++) {
+            if ((little_core_mask >> i) & 1)
+                CPU_SET(i, &cpuset);
+        }
+        haveCpuset = CPU_COUNT(&cpuset) > 0;
+    }
+
+    int demoted = 0;
+    struct dirent* ent;
+    while ((ent = readdir(dir)) != nullptr) {
+        if (ent->d_name[0] < '0' || ent->d_name[0] > '9') continue;
+
+        pid_t tid = (pid_t)std::atoi(ent->d_name);
+        if (tid <= 0) continue;
+        if (tid == self_tid) continue;
+        // Never touch the Android main UI thread — Android's input dispatcher
+        // reads from it, and any priority/affinity mutation here is exactly
+        // the class of change that causes a 10s MotionEvent ANR.
+        if (tid == tgid) continue;
+
+        char comm_path[64];
+        std::snprintf(comm_path, sizeof(comm_path), "/proc/self/task/%d/comm", (int)tid);
+        int fd = open(comm_path, O_RDONLY | O_CLOEXEC);
+        if (fd < 0) continue;
+
+        char comm[32] = {0};
+        ssize_t n = read(fd, comm, sizeof(comm) - 1);
+        close(fd);
+        if (n <= 0) continue;
+        // Strip trailing newline that the kernel appends.
+        if (comm[n - 1] == '\n') comm[n - 1] = '\0';
+
+        if (isCommToLeaveAlone(comm)) continue;
+        if (!isCommToDemote(comm)) continue;
+
+        bool changed = false;
+
+        // Raise nice from whatever it is (often -10 for Mono ThreadPriority.Highest)
+        // to 0. setpriority(PRIO_PROCESS, tid, 0) is a de-elevation and
+        // therefore does not require CAP_SYS_NICE for a same-euid caller.
+        if (setpriority(PRIO_PROCESS, tid, 0) == 0)
+            changed = true;
+
+        if (haveCpuset) {
+            if (sched_setaffinity(tid, sizeof(cpu_set_t), &cpuset) == 0)
+                changed = true;
+        }
+
+        if (changed) demoted++;
+    }
+    closedir(dir);
+    return demoted;
+}
 }
 
 #include <android/performance_hint.h>

osu.Android/OsuGameAndroid.cs

@@ -404,6 +404,50 @@ protected override void LoadComplete()
                 Logger.Log($"[osu!] Failed to pin threads: {e.Message}", LoggingTarget.Performance);
             }
 
+            // Tame background worker threads (Mono threadpool / shader-compile /
+            // OkHttp / Okio / unnamed "Thread-N" workers) out of the nice=-10
+            // display-compositor priority class Mono maps ThreadPriority.Highest
+            // to. Field tombstones from v177 show a Mono threadpool worker stuck
+            // in Veldrid's glslang::SetupBuiltinSymbolTable at nice=-10 on a big
+            // core while the Draw thread drains a 300+-item texture-upload queue
+            // — together starving the Android main UI thread past the 10s input-
+            // dispatch deadline and producing a MotionEvent ANR.
+            //
+            // The native helper walks /proc/self/task, identifies non-game
+            // workers by kernel comm, and drops them to nice=0. If we detected a
+            // big-core mask above, it ALSO pins those workers to the LITTLE-core
+            // subset (inverse of the big-core mask, masked against the real CPU
+            // count) so that shader-compile / network / finalizer work cannot
+            // preempt the Draw thread or the Android main UI thread.
+            //
+            // We apply this unconditionally — i.e. also during safe-mode — because
+            // the two latest safe-mode launches in logs.zip demonstrated that
+            // skipping CPU affinity pinning alone does NOT avoid the hang;
+            // background-thread priority elevation is the other half of the
+            // starvation equation and must be addressed independently.
+            //
+            // First apply runs synchronously here so any already-created workers
+            // are tamed immediately; additional apply passes are scheduled inside
+            // the refreshRateDelayMs block below to catch workers that are spawned
+            // later (Veldrid typically creates its shader-compile worker on first
+            // use, i.e. right when the Toolbar starts loading).
+            try
+            {
+                int coreCount = System.Environment.ProcessorCount;
+                int totalMask = coreCount >= 32 ? -1 : (1 << Math.Min(coreCount, 31)) - 1;
+                int littleMask = (~affinityMask) & totalMask;
+                if (littleMask == 0)
+                    littleMask = totalMask; // fall back to "any core" if topology unknown.
+
+                int demoted = AndroidNativeBridgeManager.TameBackgroundThreads(littleMask);
+                if (demoted > 0)
+                    Logger.Log($"[osu!] Tamed {demoted} background worker thread(s) to nice=0 (little-core mask=0x{littleMask:X})", LoggingTarget.Performance);
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine($"[osu!] TameBackgroundThreads (initial) failed: {e.Message}");
+            }
+
             // Sustained performance mode is applied LATER, together with the deferred
             // display-mode / GC-latency work below. See the Scheduler.AddDelayed block
             // further down (after base.LoadComplete()) that schedules the first apply
@@ -446,6 +490,52 @@ protected override void LoadComplete()
             // the texture-upload backpressure last time gets a wider safety margin.
             int refreshRateDelayMs = AndroidStartupSafeMode.IsActive ? 15_000 : 5_000;
 
+            // Repeat passes of background-thread taming during the Toolbar cold-start
+            // texture-upload burst. Veldrid spawns its shader-compile worker lazily
+            // on the first CompileGlslToSpirv call, which happens mid-Toolbar-load
+            // (i.e. after the synchronous taming pass above has already run). Without
+            // these follow-up passes, the newly-spawned worker inherits nice=-10
+            // from its parent and reproduces the starvation pattern. The chosen
+            // timestamps straddle the observed "Texture upload queue is large (100/
+            // 200/300)" events in the field runtime logs.
+            try
+            {
+                int coreCount = System.Environment.ProcessorCount;
+                int totalMask = coreCount >= 32 ? -1 : (1 << Math.Min(coreCount, 31)) - 1;
+                int deferredLittleMask;
+
+                if (AndroidStartupSafeMode.IsActive)
+                    deferredLittleMask = totalMask; // safe-mode: affinity disabled, use full mask.
+                else
+                {
+                    int bigMask = AndroidNativeBridgeManager.GetBigCoreMask();
+                    deferredLittleMask = (~bigMask) & totalMask;
+                    if (deferredLittleMask == 0) deferredLittleMask = totalMask;
+                }
+
+                foreach (int delayMs in new[] { 500, 1500, 3500 })
+                {
+                    int dm = delayMs;
+                    Scheduler.AddDelayed(() =>
+                    {
+                        try
+                        {
+                            int demoted = AndroidNativeBridgeManager.TameBackgroundThreads(deferredLittleMask);
+                            if (demoted > 0)
+                                Logger.Log($"[osu!] Tamed {demoted} background worker thread(s) at +{dm}ms", LoggingTarget.Performance);
+                        }
+                        catch (Exception e)
+                        {
+                            Debug.WriteLine($"[osu!] Deferred TameBackgroundThreads(+{dm}ms) failed: {e.Message}");
+                        }
+                    }, delayMs);
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine($"[osu!] Failed to schedule deferred TameBackgroundThreads passes: {e.Message}");
+            }
+
             Scheduler.AddDelayed(() =>
             {
                 // Flip the gate FIRST, then run the actual query. Any subsequent