feat(UIViewOperationQueue): Eagerly invoke non-batched createView operations (microsoft#588)

rozele · web-flow · commit 059c22297fca · 2016-08-12T11:15:11.000-04:00
Create view operations are not intended to have side-effects, so they can be evaluated eagerly as the come in, saving precious milliseconds when evaluating the batch. Fixes microsoft#531
diff --git a/ReactWindows/ReactNative/UIManager/UIViewOperationQueue.cs b/ReactWindows/ReactNative/UIManager/UIViewOperationQueue.cs
@@ -3,6 +3,8 @@
 using ReactNative.Tracing;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
 using Windows.UI.Xaml.Media;
 
 namespace ReactNative.UIManager
@@ -17,15 +19,25 @@ namespace ReactNative.UIManager
     /// </summary>
     public class UIViewOperationQueue
     {
+        private const long TicksPerFrame = 166666;
+        private const long MaxNonBatchedTicksPerFrame = 83333;
+
+        private static Stopwatch s_stopwatch = Stopwatch.StartNew();
+
         private readonly object _gate = new object();
+        private readonly object _nonBatchedGate = new object();
         private readonly double[] _measureBuffer = new double[4];
 
         private readonly NativeViewHierarchyManager _nativeViewHierarchyManager;
         private readonly ReactContext _reactContext;
 
+        private readonly IList<Action> _nonBatchedOperations = new List<Action>();
+
         private IList<Action> _operations = new List<Action>();
         private IList<Action> _batches = new List<Action>();
 
+        private long _lastRenderingTicks = -1;
+
         /// <summary>
         /// Instantiates the <see cref="UIViewOperationQueue"/>.
         /// </summary>
@@ -161,11 +173,14 @@ public void EnqueueCreateView(
             string viewClassName,
             ReactStylesDiffMap initialProps)
         {
-            EnqueueOperation(() => _nativeViewHierarchyManager.CreateView(
-                themedContext,
-                viewReactTag,
-                viewClassName,
-                initialProps));
+            lock (_nonBatchedGate)
+            {
+                _nonBatchedOperations.Add(() => _nativeViewHierarchyManager.CreateView(
+                   themedContext,
+                   viewReactTag,
+                   viewClassName,
+                   initialProps));
+            }
         }
 
         /// <summary>
@@ -380,20 +395,42 @@ public void OnShutdown()
         /// <param name="batchId">The batch identifier.</param>
         internal void DispatchViewUpdates(int batchId)
         {
-            lock (_gate)
+            var operations = _operations.Count == 0 ? null : _operations;
+            if (operations != null)
             {
-                var operations = _operations.Count == 0 ? null : _operations;
-                if (operations != null)
+                _operations = new List<Action>();
+            }
+
+            var nonBatchedOperations = default(Action[]);
+            lock (_nonBatchedGate)
+            {
+                if (_nonBatchedOperations.Count > 0)
+                {
+                    nonBatchedOperations = _nonBatchedOperations.ToArray();
+                    _nonBatchedOperations.Clear();
+                }
+                else
                 {
-                    _operations = new List<Action>();
+                    nonBatchedOperations = null;
                 }
+            }
 
+            lock (_gate)
+            {
                 _batches.Add(() =>
                 {
                     using (Tracer.Trace(Tracer.TRACE_TAG_REACT_BRIDGE, "DispatchUI")
                         .With("BatchId", batchId)
                         .Start())
                     {
+                        if (nonBatchedOperations != null)
+                        {
+                            foreach (var operation in nonBatchedOperations)
+                            {
+                                operation();
+                            }
+                        }
+
                         if (operations != null)
                         {
                             foreach (var operation in operations)
@@ -418,6 +455,15 @@ private void EnqueueOperation(Action action)
 
         private void OnRendering(object sender, object e)
         {
+            var renderingArgs = e as RenderingEventArgs;
+            if (renderingArgs != null)
+            {
+                using (Tracer.Trace(Tracer.TRACE_TAG_REACT_BRIDGE, "dispatchNonBatchedUIOperations").Start())
+                {
+                    DispatchPendingNonBatchedOperations(renderingArgs.RenderingTime);
+                }
+            }
+
             lock (_gate)
             {
                 foreach (var batch in _batches)
@@ -428,5 +474,43 @@ private void OnRendering(object sender, object e)
                 _batches.Clear();
             }
         }
+
+        private void DispatchPendingNonBatchedOperations(TimeSpan renderingTime)
+        {
+            if (_lastRenderingTicks < 0)
+            {
+                _lastRenderingTicks = renderingTime.Ticks;
+            }
+
+            var ticksSinceLastFrame = renderingTime.Ticks - _lastRenderingTicks;
+            _lastRenderingTicks = renderingTime.Ticks;
+            var lastFrameTicksOverage = Math.Max(0, ticksSinceLastFrame - TicksPerFrame);
+            var allowedTicks = MaxNonBatchedTicksPerFrame - lastFrameTicksOverage;
+
+            var frameStartTicks = s_stopwatch.ElapsedTicks;
+            while (true)
+            {
+                // Use up to `MaxNonBatchedTicksPerFrame` minus the delay in the last frame
+                var elapsedTicks = s_stopwatch.ElapsedTicks - frameStartTicks;
+                if (elapsedTicks > allowedTicks)
+                {
+                    break;
+                }
+
+                var nextOperation = default(Action);
+                lock (_nonBatchedGate)
+                {
+                    if (_nonBatchedOperations.Count == 0)
+                    {
+                        break;
+                    }
+
+                    nextOperation = _nonBatchedOperations[0];
+                    _nonBatchedOperations.RemoveAt(0);
+                }
+
+                nextOperation();
+            }
+        }
     }
 }
