perf: Oboe 1x burst buffer + pre-GC collect on high-performance session entry

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/bc693bb2-a813-42a1-98d9-8fa9d7c0f952

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>

Author: Copilot

osu.Android/Native/oboe_bridge.cpp

@@ -147,9 +147,22 @@ bool OboeBridge::open(int32_t sampleRate) {
     // This allows the system to prioritize our audio thread for stable low latency.
     stream_->setPerformanceHintEnabled(true);
 
-    // Set buffer size to 2x burst size for initial stability.
-    // LatencyTuner will then attempt to shrink it to 1x burst if stable.
-    stream_->setBufferSizeInFrames(stream_->getFramesPerBurst() * 2);
+    // Start at the minimum possible buffer: exactly 1× burst.
+    //
+    // On devices with AAudio MMAP support (Pixel 3+, Snapdragon 8 Gen 1+, most
+    // modern Android), the MMAP path writes directly to the hardware ring buffer.
+    // Starting at 1× burst achieves the minimum possible end-to-end audio latency
+    // immediately — no convergence period needed.
+    //
+    // Previously we started at 2× burst and relied on LatencyTuner to shrink it
+    // over ~512ms (128 callbacks × 4ms/callback at 48kHz/192-frame burst).
+    // That delay meant users experienced ~8ms extra audio latency for the first
+    // half-second of every gameplay session.
+    //
+    // LatencyTuner is still active and will automatically increase the buffer
+    // if underruns occur (backing off to 2× or more as needed), so stability
+    // is not compromised on devices that cannot sustain 1× burst.
+    stream_->setBufferSizeInFrames(stream_->getFramesPerBurst());
 
     // Initialise LatencyTuner for dynamic buffer management.
     tuner_ = std::make_unique<oboe::LatencyTuner>(*stream_);

osu.Android/Performance/AndroidHighPerformanceSessionManager.cs

@@ -48,6 +48,31 @@ private void enterSession()
             if (!gcLatencyModeSupported)
                 return;
 
+            // Pre-drain accumulated garbage before entering the low-latency window.
+            // SustainedLowLatency suppresses Gen2 (major) GC, so any garbage already
+            // on the heap will persist for the entire session. A non-blocking hint here
+            // asks the runtime to schedule a collection immediately — the call returns
+            // in microseconds and the GC runs in background. On .NET runtimes that
+            // support it, this eliminates the most common source of a multi-frame GC
+            // stall right at the start of gameplay (the "first-note hitbox miss"
+            // symptom observed across multiple field sessions).
+            //
+            // GCCollectionMode.Optimized + blocking:false requires .NET Core 3.0+ / .NET 5+.
+            // On Mono (older .NET for Android runtimes) it throws NotSupportedException,
+            // and on some niche OEM runtimes it may throw PlatformNotSupportedException.
+            // The catch-all deliberately swallows these: the call is a best-effort hint
+            // and the cost of it failing is exactly zero (the code path below proceeds
+            // identically).
+            try
+            {
+                GC.Collect(GC.MaxGeneration, GCCollectionMode.Optimized, blocking: false);
+            }
+            catch
+            {
+                // Non-critical hint; intentionally swallows NotSupportedException /
+                // PlatformNotSupportedException on older or non-.NET-Core runtimes.
+            }
+
             try
             {
                 originalGCMode = GCSettings.LatencyMode;