perf: update framework submodule + optimize gameplay hot paths

.github/workflows/ci.yml

@@ -24,6 +24,13 @@ jobs:
         with:
           dotnet-version: "10.0.x"
 
+      - name: Cache NuGet packages
+        uses: actions/cache@v5
+        with:
+          path: ~/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
       - name: Restore Tools
         run: dotnet tool restore
 
@@ -94,6 +101,13 @@ jobs:
         with:
           dotnet-version: "10.0.x"
 
+      - name: Cache NuGet packages
+        uses: actions/cache@v5
+        with:
+          path: ~/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
       - name: Compile
         run: dotnet build -c Debug -warnaserror osu.Desktop.slnf
 
@@ -171,6 +185,13 @@ jobs:
         with:
           dotnet-version: "10.0.x"
 
+      - name: Cache NuGet packages
+        uses: actions/cache@v5
+        with:
+          path: ~/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
       - name: Install .NET workloads
         run: dotnet workload install android
 
@@ -192,6 +213,14 @@ jobs:
         uses: actions/setup-dotnet@v5
         with:
           dotnet-version: "10.0.x"
+
+      - name: Cache NuGet packages
+        uses: actions/cache@v5
+        with:
+          path: ~/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
       - name: Set Xcode version
         run: sudo xcode-select -s /Applications/Xcode_26.3.app
 

osu.Game/Online/OnlineStatusNotifier.cs

@@ -161,6 +161,10 @@ protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
+            apiState.UnbindAll();
+            multiplayerState.UnbindAll();
+            spectatorState.UnbindAll();
+
             if (notificationsClient.IsNotNull())
                 notificationsClient.MessageReceived -= notifyAboutForcedDisconnection;
 

osu.Game/Rulesets/Scoring/HitEventExtensions.cs

@@ -63,12 +63,23 @@ public static class HitEventExtensions
         /// </returns>
         public static double? CalculateAverageHitError(this IEnumerable<HitEvent> hitEvents)
         {
-            double[] timeOffsets = hitEvents.Where(AffectsUnstableRate).Select(ev => ev.TimeOffset).ToArray();
+            // Single-pass mean using running sum — avoids allocating a temporary array.
+            double sum = 0;
+            int count = 0;
 
-            if (timeOffsets.Length == 0)
+            foreach (var ev in hitEvents)
+            {
+                if (!AffectsUnstableRate(ev))
+                    continue;
+
+                sum += ev.TimeOffset;
+                count++;
+            }
+
+            if (count == 0)
                 return null;
 
-            return timeOffsets.Average();
+            return sum / count;
         }
 
         /// <summary>

osu.Game/Rulesets/UI/DrawableRuleset.cs

@@ -271,7 +271,7 @@ public bool RemoveHitObject(TObject hitObject)
                 return true;
 
             // If the entry was not removed from the playfield, assume the hitobject is not being pooled and attempt a direct drawable removal.
-            var drawableObject = Playfield.AllHitObjects.SingleOrDefault(d => d.HitObject == hitObject);
+            var drawableObject = Playfield.AllHitObjects.FirstOrDefault(d => d.HitObject == hitObject);
             if (drawableObject != null)
                 return Playfield.Remove(drawableObject);
 

osu.Game/Rulesets/UI/GameplaySampleTriggerSource.cs

@@ -64,9 +64,8 @@ public virtual void Play()
             if (nextObject == null)
                 return;
 
-            var samples = nextObject.Samples
-                                    .Cast<ISampleInfo>()
-                                    .ToArray();
+            // HitSampleInfo implements ISampleInfo, so array covariance lets us skip .Cast<>().
+            var samples = nextObject.Samples.ToArray();
 
             PlaySamples(samples);
         }
@@ -103,10 +102,25 @@ protected override void Update()
             {
                 // We need to use lifetime entries to find the next object (we can't just use `hitObjectContainer.Objects` due to pooling - it may even be empty).
                 // If required, we can make this lookup more efficient by adding support to get next-future-entry in LifetimeEntryManager.
-                var candidate =
-                    // Use alive entries first as an optimisation.
-                    hitObjectContainer.AliveEntries.Keys.Where(e => !isAlreadyHit(e)).MinBy(e => e.HitObject.StartTime)
-                    ?? hitObjectContainer.Entries.Where(e => !isAlreadyHit(e)).MinBy(e => e.HitObject.StartTime);
+
+                // Use alive entries first as an optimisation (single-pass minimum, no LINQ allocation).
+                HitObjectLifetimeEntry? candidate = null;
+
+                foreach (var e in hitObjectContainer.AliveEntries.Keys)
+                {
+                    if (!isAlreadyHit(e) && (candidate == null || e.HitObject.StartTime < candidate.HitObject.StartTime))
+                        candidate = e;
+                }
+
+                // Fall back to full entries if no alive non-judged entry found.
+                if (candidate == null)
+                {
+                    foreach (var e in hitObjectContainer.Entries)
+                    {
+                        if (!isAlreadyHit(e) && (candidate == null || e.HitObject.StartTime < candidate.HitObject.StartTime))
+                            candidate = e;
+                    }
+                }
 
                 // In the case there are no non-judged objects, the last hit object should be used instead.
                 if (candidate == null)
@@ -135,7 +149,23 @@ protected override void Update()
 
             // Else we want the earliest valid nested.
             // In cases of nested objects, they will always have earlier sample data than their parent object.
-            return getAllNested(mostValidObject.HitObject).OrderBy(h => h.GetEndTime()).SkipWhile(h => h.GetEndTime() <= getReferenceTime()).FirstOrDefault() ?? mostValidObject.HitObject;
+            // Single-pass scan avoids the OrderBy + SkipWhile + FirstOrDefault LINQ chain.
+            double referenceTime = getReferenceTime();
+            HitObject? best = null;
+            double bestEnd = double.MaxValue;
+
+            foreach (var nested in getAllNested(mostValidObject.HitObject))
+            {
+                double end = nested.GetEndTime();
+
+                if (end > referenceTime && end < bestEnd)
+                {
+                    best = nested;
+                    bestEnd = end;
+                }
+            }
+
+            return best ?? mostValidObject.HitObject;
         }
 
         private bool isAlreadyHit(HitObjectLifetimeEntry h) => h.AllJudged;

osu.Game/Rulesets/UI/HitObjectContainer.cs

@@ -5,7 +5,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.TypeExtensions;
@@ -19,9 +18,42 @@ namespace osu.Game.Rulesets.UI
 {
     public partial class HitObjectContainer : PooledDrawableWithLifetimeContainer<HitObjectLifetimeEntry, DrawableHitObject>, IHitObjectContainer
     {
-        public IEnumerable<DrawableHitObject> Objects => InternalChildren.Cast<DrawableHitObject>().OrderBy(h => h.HitObject.StartTime);
+        /// <summary>
+        /// All <see cref="DrawableHitObject"/>s in this container, sorted by ascending <see cref="HitObject.StartTime"/>.
+        /// </summary>
+        /// <remarks>
+        /// Since internal children are already sorted by descending <see cref="HitObject.StartTime"/>
+        /// (via <see cref="Compare"/>), we reverse-enumerate to avoid an O(n log n) sort on every access.
+        /// </remarks>
+        public IEnumerable<DrawableHitObject> Objects => enumerateByStartTimeAscending();
+
+        /// <summary>
+        /// All alive <see cref="DrawableHitObject"/>s in this container, sorted by ascending <see cref="HitObject.StartTime"/>.
+        /// </summary>
+        /// <remarks>
+        /// The alive entries dictionary is unordered, so we must sort.
+        /// However, the alive set is typically much smaller than the full set, making this cheaper
+        /// than sorting all children. We use a List + Sort (in-place) to avoid LINQ iterator allocations.
+        /// </remarks>
+        public IEnumerable<DrawableHitObject> AliveObjects => getSortedAliveObjects();
+
+        private IEnumerable<DrawableHitObject> enumerateByStartTimeAscending()
+        {
+            var children = InternalChildren;
+
+            for (int i = children.Count - 1; i >= 0; i--)
+            {
+                if (children[i] is DrawableHitObject hitObject)
+                    yield return hitObject;
+            }
+        }
 
-        public IEnumerable<DrawableHitObject> AliveObjects => AliveEntries.Values.OrderBy(h => h.HitObject.StartTime);
+        private List<DrawableHitObject> getSortedAliveObjects()
+        {
+            var list = new List<DrawableHitObject>(AliveEntries.Values);
+            list.Sort(static (a, b) => a.HitObject.StartTime.CompareTo(b.HitObject.StartTime));
+            return list;
+        }
 
         /// <summary>
         /// Invoked when a <see cref="DrawableHitObject"/> is judged.

osu.Game/Screens/Edit/Compose/HitObjectUsageEventBuffer.cs

@@ -59,7 +59,7 @@ public HitObjectUsageEventBuffer([NotNull] Playfield playfield)
         private void onHitObjectUsageBegan(HitObject hitObject)
         {
             if (usageFinishedHitObjects.Remove(hitObject))
-                HitObjectUsageTransferred?.Invoke(hitObject, playfield.AllHitObjects.Single(d => d.HitObject == hitObject));
+                HitObjectUsageTransferred?.Invoke(hitObject, playfield.AllHitObjects.First(d => d.HitObject == hitObject));
             else
                 HitObjectUsageBegan?.Invoke(hitObject);
         }

osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs

@@ -131,7 +131,7 @@ void preventMiss(HitObject hitObject)
             {
                 var drawableObject = DrawableRuleset.Playfield.HitObjectContainer
                                                     .AliveObjects
-                                                    .SingleOrDefault(it => it.HitObject == hitObject);
+                                                    .FirstOrDefault(it => it.HitObject == hitObject);
 
                 if (drawableObject != null)
                     preventMissOnDrawable(drawableObject);

osu.Game/Screens/Play/HUD/ClicksPerSecond/ClicksPerSecondController.cs

@@ -36,19 +36,29 @@ protected override void Update()
             double latestValidTime = clock.CurrentTime;
             double earliestTimeValid = latestValidTime - 1000 * gameplayClock.GetTrueGameplayRate();
 
+            // Timestamps are added in chronological order (from clock.CurrentTime),
+            // so we can use binary-search-style trimming instead of per-element RemoveAt.
+
+            // Trim future timestamps caused by rewinding (remove from the end in one batch).
+            // RemoveRange from the end is a single operation vs repeated RemoveAt calls.
+            int trimStart = timestamps.Count;
+
+            while (trimStart > 0 && timestamps[trimStart - 1] > latestValidTime)
+                trimStart--;
+
+            if (trimStart < timestamps.Count)
+                timestamps.RemoveRange(trimStart, timestamps.Count - trimStart);
+
+            // Count timestamps within the valid 1-second window.
+            // Since the list is in chronological order, scan backwards until we leave the window.
             int count = 0;
 
             for (int i = timestamps.Count - 1; i >= 0; i--)
             {
-                // handle rewinding by removing future timestamps as we go
-                if (timestamps[i] > latestValidTime)
-                {
-                    timestamps.RemoveAt(i);
-                    continue;
-                }
-
-                if (timestamps[i] >= earliestTimeValid)
-                    count++;
+                if (timestamps[i] < earliestTimeValid)
+                    break;
+
+                count++;
             }
 
             Value = count;

osu.Game/Screens/Play/HUD/HitErrorMeters/ColourHitErrorMeter.cs

@@ -115,10 +115,32 @@ public void Push(HitErrorShape shape)
 
             private void removeExtraJudgements()
             {
-                var remainingChildren = Children.Where(c => !c.IsRemoved);
+                // Count non-removed children and remove excess starting from the oldest.
+                // This avoids re-enumerating via LINQ .Count()/.First() on every iteration.
+                int remaining = 0;
 
-                while (remainingChildren.Count() > JudgementCount.Value)
-                    remainingChildren.First().Remove();
+                foreach (var c in Children)
+                {
+                    if (!c.IsRemoved)
+                        remaining++;
+                }
+
+                int target = JudgementCount.Value;
+
+                if (remaining <= target)
+                    return;
+
+                foreach (var c in Children)
+                {
+                    if (remaining <= target)
+                        break;
+
+                    if (!c.IsRemoved)
+                    {
+                        c.Remove();
+                        remaining--;
+                    }
+                }
             }
 
             private void updateMetrics()