Pull out ActionThrottler into class and fix delay bug.

Author: JakeRadMSFT

src/Microsoft.ML.AutoML.Interactive/ActionThrottler.cs

@@ -0,0 +1,50 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.ML.AutoML
+{
+    internal class ActionThrottler
+    {
+        private readonly Action _action;
+        private readonly TimeSpan _minDelay;
+
+        private DateTime _nextUpdateTime = DateTime.MinValue;
+        private int _updatePending = 0;
+
+        /// <summary>
+        /// This constructor initializes an ActionThrottler that ensures <paramref name="action"/> runs no more than once per <paramref name="minDelay"/>.
+        /// </summary>
+        /// <param name="action">The action to thorttle.</param>
+        /// <param name="minDelay">Timespan to indicate the minimum delay between each time action is executed.</param>
+        public ActionThrottler(Action action, TimeSpan minDelay)
+        {
+            _minDelay = minDelay;
+            _action = action;
+        }
+
+
+        public async Task ExecuteAsync()
+        {
+            if (Interlocked.CompareExchange(ref _updatePending, 1, 0) == 0) // _updatePending is int initialized with 0
+            {
+                DateTime currentTime = DateTime.UtcNow;
+
+                if (_nextUpdateTime > currentTime)
+                {
+                    await Task.Delay(_nextUpdateTime - currentTime);
+                }
+                _action();
+                _nextUpdateTime = DateTime.UtcNow + _minDelay;
+                _updatePending = 0;
+            }
+        }
+    }
+}

src/Microsoft.ML.AutoML.Interactive/NotebookMonitor.cs

@@ -14,8 +14,8 @@ namespace Microsoft.ML.AutoML
 {
     public class NotebookMonitor : IMonitor
     {
+        private readonly ActionThrottler _updateThrottler;
         private DisplayedValue _valueToUpdate;
-        private DateTime _lastUpdate = DateTime.MinValue;
 
         public TrialResult BestTrial { get; set; }
         public TrialResult MostRecentTrial { get; set; }
@@ -27,12 +27,14 @@ public NotebookMonitor()
         {
             CompletedTrials = new List<TrialResult>();
             TrialData = new DataFrame(new PrimitiveDataFrameColumn<int>("Trial"), new PrimitiveDataFrameColumn<float>("Metric"), new StringDataFrameColumn("Trainer"), new StringDataFrameColumn("Parameters"));
+            _updateThrottler = new ActionThrottler(Update, TimeSpan.FromSeconds(5));
         }
 
         public void ReportBestTrial(TrialResult result)
         {
             BestTrial = result;
-            Update();
+
+            ThrottledUpdate();
         }
 
         public void ReportCompletedTrial(TrialResult result)
@@ -49,46 +51,36 @@ public void ReportCompletedTrial(TrialResult result)
                 new KeyValuePair<string, object>("Trainer",result.TrialSettings.Pipeline.ToString().Replace("Unknown=>","")),
                 new KeyValuePair<string, object>("Parameters",activeRunParam),
             }, true);
-            Update();
+
+            ThrottledUpdate();
         }
 
         public void ReportFailTrial(TrialResult result)
         {
             // TODO figure out what to do with failed trials.
-            Update();
+            ThrottledUpdate();
         }
 
         public void ReportRunningTrial(TrialSettings setting)
         {
             ActiveTrial = setting;
-            Update();
+            ThrottledUpdate();
         }
 
-        private int _updatePending = 0;
-        public void Update()
+        private void ThrottledUpdate()
         {
-            Task.Run(async () =>
-            {
-                if (Interlocked.CompareExchange(ref _updatePending, 1, 0) == 0) // _updatePending is int initialized with 0
-                {
-                    DateTime n = DateTime.UtcNow;
-                    if (n - _lastUpdate < TimeSpan.FromSeconds(5))
-                    {
-                        await Task.Delay(n - _lastUpdate);
-                    }
-
-                    _valueToUpdate.Update(this);
-                    _lastUpdate = n;
-                    _updatePending = 0;
-                }
-            });
+            Task.Run(async () => await _updateThrottler.ExecuteAsync());
+        }
 
+        public void Update()
+        {
+            _valueToUpdate.Update(this);
         }
 
         public void SetUpdate(DisplayedValue valueToUpdate)
         {
             _valueToUpdate = valueToUpdate;
-            Update();
+            ThrottledUpdate();
         }
     }
 }