perf: promote 42 IF-authored WPF optimizations (eval-validated)

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/TextFormatting/LineServicesCallbacks.cs

@@ -2951,6 +2951,7 @@ out nominalY
             }
             else
             {
+                double emSizeReal = textFormatterImp.IdealToReal(lsrun.EmSize, currentLine.PixelsPerDip);
                 if (justify)
                 {
                     AdjustMetricsForDisplayModeJustifiedText(
@@ -2967,21 +2968,22 @@ out glyphAdvances
                 }
                 else
                 {
-                    glyphAdvances = new List<double>(glyphCount);
+                    glyphAdvances = new ThousandthOfEmRealDoubles(emSizeReal, glyphCount);
                     for (int i = 0; i < glyphCount; i++)
                     {
-                        glyphAdvances.Add(textFormatterImp.IdealToReal(piJustifiedGlyphAdvances[i], currentLine.PixelsPerDip));
+                        glyphAdvances[i] = textFormatterImp.IdealToReal(piJustifiedGlyphAdvances[i], currentLine.PixelsPerDip);
                     }
                 }
-                glyphOffsets  = new List<Point>(glyphCount);
+                ThousandthOfEmRealPoints glyphOffsetsTyped = new ThousandthOfEmRealPoints(emSizeReal, glyphCount);
                 for (int i = 0; i < glyphCount; i++)
                 {
                     glyphIndices[i] = puGlyphs[i];
-                    glyphOffsets.Add(new Point(
+                    glyphOffsetsTyped[i] = new Point(
                             textFormatterImp.IdealToReal(piiGlyphOffsets[i].du, currentLine.PixelsPerDip),
                             textFormatterImp.IdealToReal(piiGlyphOffsets[i].dv, currentLine.PixelsPerDip)
-                            ));
+                            );
                 }
+                glyphOffsets = glyphOffsetsTyped;
             }
 
 #if CHECK_GLYPHS
@@ -3104,11 +3106,14 @@ out charWidths
                     }
                     else
                     {
-                        charWidths = new List<double>(cchText);
+                        ThousandthOfEmRealDoubles charWidthsTyped = new ThousandthOfEmRealDoubles(
+                            textFormatterImp.IdealToReal(lsrun.EmSize, Draw.CurrentLine.PixelsPerDip),
+                            cchText);
                         for (int i = 0; i < cchText; i++)
                         {
-                            charWidths.Add(textFormatterImp.IdealToReal(piCharAdvances[i], Draw.CurrentLine.PixelsPerDip));
+                            charWidthsTyped[i] = textFormatterImp.IdealToReal(piCharAdvances[i], Draw.CurrentLine.PixelsPerDip);
                         }
+                        charWidths = charWidthsTyped;
                     }
                     for (int i = 0; i < cchText; i++)
                     {

src/Microsoft.DotNet.Wpf/src/PresentationCore/MS/internal/UIElementHelper.cs

@@ -11,6 +11,10 @@ namespace MS.Internal
 {
     internal static class UIElementHelper
     {
+        [ThreadStatic]
+        private static Stack<DependencyObject> _branchNodeStackCache;
+
+
         internal static bool IsHitTestVisible(DependencyObject o)
         {
             Debug.Assert(o != null, "UIElementHelper.IsHitTestVisible called with null argument");
@@ -138,7 +142,8 @@ internal static void InvalidateAutomationAncestors(DependencyObject o)
             UIElement3D e3d = null;
             ContentElement ce = null;
 
-            Stack<DependencyObject> branchNodeStack = new Stack<DependencyObject>();
+            var branchNodeStack = _branchNodeStackCache ??= new Stack<DependencyObject>();
+            branchNodeStack.Clear(); // defensive: guard against unexpected residue from any prior walk
             bool continueInvalidation = true;
 
             while (o != null && continueInvalidation)

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/LayoutManager.cs

@@ -575,9 +575,9 @@ private void fireLayoutUpdateEvent()
             {
                 _inFireLayoutUpdated = true;
 
-                LayoutEventList.ListItem [] copy = LayoutEvents.CopyToArray();
+                LayoutEventList.ListItem [] copy = LayoutEvents.CopyToReusableArray(out int copyCount);
 
-                for(int i=0; i<copy.Length; i++)
+                for(int i=0; i<copyCount; i++)
                 {
                     LayoutEventList.ListItem item = copy[i];
                     //store handler here in case if thread gets pre-empted between check for IsAlive and invocation
@@ -678,9 +678,9 @@ private void fireAutomationEvents()
                 _inFireAutomationEvents = true;
                 _firePostLayoutEvents = false;
 
-                LayoutEventList.ListItem [] copy = AutomationEvents.CopyToArray();
+                LayoutEventList.ListItem [] copy = AutomationEvents.CopyToReusableArray(out int copyCount);
 
-                for(int i=0; i<copy.Length; i++)
+                for(int i=0; i<copyCount; i++)
                 {
                     LayoutEventList.ListItem item = copy[i];
                     //store peer here in case if thread gets pre-empted between check for IsAlive and invocation
@@ -729,6 +729,12 @@ internal LayoutEventList AutomationEvents
 
         internal AutomationPeer[] GetAutomationRoots()
         {
+            // Use the parameterless CopyToArray (fresh snapshot) here, NOT
+            // CopyToReusableArray. This method is reachable from inside
+            // fireAutomationEvents → peer.FireAutomationEvents() →
+            // AutomationPeer.ValidateConnected (LayoutManager.cs callers in
+            // AutomationPeer.cs:578), which would otherwise overwrite the
+            // shared _copyBuffer mid-iteration of the outer fire loop.
             LayoutEventList.ListItem [] copy = AutomationEvents.CopyToArray();
 
             AutomationPeer[] peers = new AutomationPeer[copy.Length];
@@ -1127,6 +1133,57 @@ internal ListItem[] CopyToArray()
             return copy;
         }
 
+        // Per-instance scratch buffer for CopyToReusableArray. Each call to
+        // fireLayoutUpdateEvent / fireAutomationEvents (one per render pass
+        // when there is layout dirtiness) used to allocate a fresh
+        // ListItem[_count]; with the typical hundreds of UIElements that
+        // subscribe to LayoutUpdated that's hundreds of MB of gen0 churn
+        // during sustained playback. The buffer is shared across calls, so
+        // it is only safe to use from a caller that can guarantee no other
+        // CopyToReusableArray call on the same LayoutEventList runs before
+        // iteration over the returned buffer is complete. Reentrant or
+        // on-demand callers (e.g. GetAutomationRoots, which can be reached
+        // from inside FireAutomationEvents handlers via AutomationPeer
+        // connectivity checks) must use the parameterless CopyToArray()
+        // instead so they get a private snapshot.
+        //
+        // Caller must use the returned `count`; buffer length may exceed it.
+        private ListItem[] _copyBuffer;
+
+        internal ListItem[] CopyToReusableArray(out int count)
+        {
+            count = _count;
+            ListItem[] buffer = _copyBuffer;
+            if (buffer == null || buffer.Length < count)
+            {
+                // Round up to next power of two so steady-state subscriber
+                // counts don't keep reallocating on small swings.
+                int newSize = buffer == null ? 16 : buffer.Length;
+                while (newSize < count) newSize *= 2;
+                buffer = new ListItem[newSize];
+                _copyBuffer = buffer;
+            }
+
+            ListItem t = _head;
+            int i = 0;
+            while (t != null)
+            {
+                buffer[i++] = t;
+                t = t.Next;
+            }
+            // Clear the tail of any stale references from a previous fire so
+            // ListItems removed during/after that fire can be GC'd. Removed
+            // ListItems already null their Target (see reuseListItem), so
+            // this only retains lightweight WeakReference shells, but we
+            // null them anyway to keep the invariant "buffer beyond `count`
+            // is null" so callers can't mistakenly read stale entries.
+            for (int j = i; j < buffer.Length && buffer[j] != null; j++)
+            {
+                buffer[j] = null;
+            }
+            return buffer;
+        }
+
         internal int Count
         {
             get

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Animation/Clock.cs

@@ -2581,10 +2581,16 @@ private void ComputeEvents(TimeSpan? expirationTime,
 
                 // consider caching this condition
                 // We check whether our active period exists before using it to compute intervals
-                if (!expirationTime.HasValue       // If activePeriod extends forever, 
-                    || expirationTime >= _beginTime)  // OR if activePeriod extends to or beyond _beginTime, 
+                if (!expirationTime.HasValue       // If activePeriod extends forever,
+                    || expirationTime >= _beginTime)  // OR if activePeriod extends to or beyond _beginTime,
                 {
                     // Check for CurrentTimeInvalidated
+                    // The activePeriod TIC was previously freshly allocated per tick (3 small arrays via
+                    // CreateClosedOpenInterval / CreateInfiniteClosedInterval), but it is only used for two
+                    // read-only Intersects calls (one here on the Intersects, and one inside
+                    // ComputeIntervalsWithParentIntersection on IntersectsInverseOf) and never escapes the
+                    // call stack. We rebuild it in place on a per-thread scratch buffer to eliminate the
+                    // per-tick array allocations on every animated clock.
                     TimeIntervalCollection activePeriod;
                     if (expirationTime.HasValue)
                     {
@@ -2594,12 +2600,14 @@ private void ComputeEvents(TimeSpan? expirationTime,
                         }
                         else
                         {
-                            activePeriod = TimeIntervalCollection.CreateClosedOpenInterval(_beginTime.Value, expirationTime.Value);
+                            s_scratchActivePeriod.RebuildAsClosedOpenInterval(_beginTime.Value, expirationTime.Value);
+                            activePeriod = s_scratchActivePeriod;
                         }
                     }
                     else  // expirationTime is infinity
                     {
-                        activePeriod = TimeIntervalCollection.CreateInfiniteClosedInterval(_beginTime.Value);
+                        s_scratchActivePeriod.RebuildAsInfiniteClosedInterval(_beginTime.Value);
+                        activePeriod = s_scratchActivePeriod;
                     }
 
                     // If we have an intersection between parent domain times and the interval over which we
@@ -2797,7 +2805,11 @@ private void ComputeIntervalsWithHoldEnd(
         {
             Debug.Assert(endOfActivePeriod.HasValue);
 
-            TimeIntervalCollection fillPeriod = TimeIntervalCollection.CreateInfiniteClosedInterval(endOfActivePeriod.Value);
+            // Reuse the per-thread scratch buffer here too; this path is mutually exclusive with the
+            // activePeriod path in ComputeEvents (the caller takes the Intersects-true OR Intersects-false
+            // branch, not both), so a single scratch slot suffices for both fillPeriod and activePeriod.
+            s_scratchActivePeriod.RebuildAsInfiniteClosedInterval(endOfActivePeriod.Value);
+            TimeIntervalCollection fillPeriod = s_scratchActivePeriod;
 
             if (parentIntervalCollection.Intersects(fillPeriod))  // We enter or leave Fill period
             {
@@ -4469,6 +4481,17 @@ internal static void CleanKnownClocksTable()
 
         private static Int64        s_TimeSpanTicksPerSecond = TimeSpan.FromSeconds(1).Ticks;
 
+        // Per-thread scratch TimeIntervalCollection used by ComputeEvents / ComputeIntervalsWithHoldEnd
+        // to avoid the per-tick allocation of three small arrays for activePeriod / fillPeriod. The
+        // struct's _nodeTime / _nodeIsPoint / _nodeIsInterval buffers are allocated on first use and
+        // reused across every Clock.ComputeEvents call on the dispatcher thread thereafter. Both
+        // consumers (parentIntervalCollection.Intersects(activePeriod) and
+        // parentIntervalCollection.IntersectsInverseOf(activePeriod)) read this struct without mutating
+        // its underlying arrays, and ComputeEvents never recurses into another Clock's ComputeEvents
+        // before its own consumer calls return, so a single shared scratch slot is safe.
+        [ThreadStatic]
+        private static TimeIntervalCollection s_scratchActivePeriod;
+
         #endregion // Linking data
 
         #region Debug data

src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/Media/Animation/TimeIntervalCollection.cs

@@ -342,6 +342,64 @@ internal static TimeIntervalCollection CreateInfiniteClosedInterval(TimeSpan fro
             return new TimeIntervalCollection(from, true);
         }
 
+        // Rebuilds this TIC in place as the closed-open interval [from, to). Reuses the existing
+        // _nodeTime / _nodeIsPoint / _nodeIsInterval buffers (allocates only on first call when
+        // they are null). Mirrors the semantics of CreateClosedOpenInterval(from, to) exactly,
+        // including the from==to single-point degenerate case and the from>to swap.
+        internal void RebuildAsClosedOpenInterval(TimeSpan from, TimeSpan to)
+        {
+            _containsNullPoint = false;
+            _invertCollection = false;
+            _current = 0;
+
+            EnsureAllocatedCapacity(_minimumCapacity);
+
+            _nodeTime[0] = from;
+
+            if (from == to)
+            {
+                // Match TimeIntervalCollection(from,true,to,false) for from==to: single point at from.
+                _nodeIsPoint[0] = true;
+                _nodeIsInterval[0] = false;
+                _count = 1;
+            }
+            else if (from < to)
+            {
+                _nodeIsPoint[0] = true;        // includeFrom
+                _nodeIsInterval[0] = true;
+                _nodeTime[1] = to;
+                _nodeIsPoint[1] = false;       // !includeTo
+                _nodeIsInterval[1] = false;    // explicit reset (constructor relied on fresh-array default)
+                _count = 2;
+            }
+            else  // from > to: reversed, swap to [to, from) shape
+            {
+                _nodeTime[0] = to;
+                _nodeIsPoint[0] = false;       // !includeTo
+                _nodeIsInterval[0] = true;
+                _nodeTime[1] = from;
+                _nodeIsPoint[1] = true;        // includeFrom
+                _nodeIsInterval[1] = false;    // explicit reset
+                _count = 2;
+            }
+        }
+
+        // Rebuilds this TIC in place as the half-infinite closed interval [from, +infinity).
+        // Reuses existing buffers (allocates only on first call). Mirrors CreateInfiniteClosedInterval(from).
+        internal void RebuildAsInfiniteClosedInterval(TimeSpan from)
+        {
+            _containsNullPoint = false;
+            _invertCollection = false;
+            _current = 0;
+
+            EnsureAllocatedCapacity(_minimumCapacity);
+
+            _nodeTime[0] = from;
+            _nodeIsPoint[0] = true;            // includePoint
+            _nodeIsInterval[0] = true;
+            _count = 1;
+        }
+
         /// <summary>
         /// Creates an empty collection
         /// </summary>