Fix performance issue with ReadKey changes (#621)

* Fix performance issue with ReadKey changes

- Separated the ReadKey changes to be platform specific.  This way we
  don't need a busy loop to wait until a key is available on Windows.

- Changed the Unix implementation of ReadKey to wait for a longer
  period of time between Console.KeyAvailable checks if the user
  has not pressed a key within the last five seconds. This change
  was made to ensure the CPU is able to enter low power mode.

* Addressing feedback

- Added final new lines to new files

- Added VSCode workspace setting to automatically add final new lines

- Changed unix readkey long delay to 300ms from 400ms

- Added a short wait timer to unix readkey short delay to reduce CPU
  consumption

Author: SeeminglyScience

.vscode/settings.json

@@ -2,5 +2,6 @@
 {
     "editor.tabSize": 4,
     "editor.insertSpaces": true,
-    "files.trimTrailingWhitespace": true
-}
+    "files.trimTrailingWhitespace": true,
+    "files.insertFinalNewline": true
+}

src/PowerShellEditorServices/Console/ConsoleReadLine.cs

@@ -6,9 +6,9 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
-using UnixConsoleEcho;
 
 namespace Microsoft.PowerShell.EditorServices.Console
 {
@@ -20,12 +20,28 @@ namespace Microsoft.PowerShell.EditorServices.Console
     internal class ConsoleReadLine
     {
         #region Private Field
+        private static IConsoleOperations s_consoleProxy;
 
         private PowerShellContext powerShellContext;
 
         #endregion
 
         #region Constructors
+        static ConsoleReadLine()
+        {
+            // Maybe we should just include the RuntimeInformation package for FullCLR?
+            #if CoreCLR
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                s_consoleProxy = new WindowsConsoleOperations();
+                return;
+            }
+
+            s_consoleProxy = new UnixConsoleOperations();
+            #else
+            s_consoleProxy = new WindowsConsoleOperations();
+            #endif
+        }
 
         public ConsoleReadLine(PowerShellContext powerShellContext)
         {
@@ -130,24 +146,7 @@ public async Task<SecureString> ReadSecureLine(CancellationToken cancellationTok
 
         private static async Task<ConsoleKeyInfo> ReadKeyAsync(CancellationToken cancellationToken)
         {
-            await WaitForKeyAvailableAsync(cancellationToken);
-            return Console.ReadKey(true);
-        }
-
-        private static async Task WaitForKeyAvailableAsync(CancellationToken cancellationToken)
-        {
-            InputEcho.Disable();
-            try
-            {
-                while (!Console.KeyAvailable)
-                {
-                    await Task.Delay(50, cancellationToken);
-                }
-            }
-            finally
-            {
-                InputEcho.Enable();
-            }
+            return await s_consoleProxy.ReadKeyAsync(cancellationToken);
         }
 
         private async Task<string> ReadLine(bool isCommandLine, CancellationToken cancellationToken)

src/PowerShellEditorServices/Console/IConsoleOperations.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.PowerShell.EditorServices.Console
+{
+    /// <summary>
+    /// Provides platform specific console utilities.
+    /// </summary>
+    public interface IConsoleOperations
+    {
+        /// <summary>
+        /// Obtains the next character or function key pressed by the user asynchronously.
+        /// Does not block when other console API's are called.
+        /// </summary>
+        /// <param name="cancellationToken">The CancellationToken to observe.</param>
+        /// <returns>
+        /// A task that will complete with a result of the key pressed by the user.
+        /// </returns>
+        Task<ConsoleKeyInfo> ReadKeyAsync(CancellationToken cancellationToken);
+    }
+}

src/PowerShellEditorServices/Console/UnixConsoleOperations.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using UnixConsoleEcho;
+
+namespace Microsoft.PowerShell.EditorServices.Console
+{
+    internal class UnixConsoleOperations : IConsoleOperations
+    {
+        private const int LONG_READ_DELAY = 300;
+
+        private const int SHORT_READ_TIMEOUT = 5000;
+
+        private static readonly ManualResetEventSlim _waitHandle = new ManualResetEventSlim();
+
+        private SemaphoreSlim _readKeyHandle = new SemaphoreSlim(1, 1);
+
+        internal UnixConsoleOperations()
+        {
+            // Switch between long and short wait periods depending on if the
+            // user has recently (last 5 seconds) pressed a key to avoid preventing
+            // the CPU from entering low power mode.
+            WaitForKeyAvailable = LongWaitForKey;
+        }
+
+        public async Task<ConsoleKeyInfo> ReadKeyAsync(CancellationToken cancellationToken)
+        {
+            await _readKeyHandle.WaitAsync(cancellationToken);
+
+            // I tried to replace this library with a call to `stty -echo`, but unfortunately
+            // the library also sets up allowing backspace to trigger `Console.KeyAvailable`.
+            InputEcho.Disable();
+            try
+            {
+                while (!await WaitForKeyAvailable(cancellationToken));
+            }
+            finally
+            {
+                InputEcho.Enable();
+                _readKeyHandle.Release();
+            }
+
+            return System.Console.ReadKey(intercept: true);
+        }
+
+        private Func<CancellationToken, Task<bool>> WaitForKeyAvailable;
+
+        private async Task<bool> LongWaitForKey(CancellationToken cancellationToken)
+        {
+            while (!System.Console.KeyAvailable)
+            {
+                await Task.Delay(LONG_READ_DELAY, cancellationToken);
+            }
+
+            WaitForKeyAvailable = ShortWaitForKey;
+            return true;
+        }
+
+        private async Task<bool> ShortWaitForKey(CancellationToken cancellationToken)
+        {
+            if (await SpinUntilKeyAvailable(SHORT_READ_TIMEOUT, cancellationToken))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                return true;
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+            WaitForKeyAvailable = LongWaitForKey;
+            return false;
+        }
+
+        private async Task<bool> SpinUntilKeyAvailable(int millisecondsTimeout, CancellationToken cancellationToken)
+        {
+            return await Task<bool>.Factory.StartNew(
+                () => SpinWait.SpinUntil(
+                    () =>
+                    {
+                        // The wait handle is never set, it's just used to enable cancelling the wait.
+                        _waitHandle.Wait(30, cancellationToken);
+                        return System.Console.KeyAvailable || cancellationToken.IsCancellationRequested;
+                    },
+                    millisecondsTimeout));
+        }
+    }
+}

src/PowerShellEditorServices/Console/WindowsConsoleOperations.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.PowerShell.EditorServices.Console
+{
+    internal class WindowsConsoleOperations : IConsoleOperations
+    {
+        private ConsoleKeyInfo? _bufferedKey;
+
+        private SemaphoreSlim _readKeyHandle = new SemaphoreSlim(1, 1);
+
+        public async Task<ConsoleKeyInfo> ReadKeyAsync(CancellationToken cancellationToken)
+        {
+            await _readKeyHandle.WaitAsync(cancellationToken);
+            try
+            {
+                return
+                    _bufferedKey.HasValue
+                        ? _bufferedKey.Value
+                        : await Task.Factory.StartNew(
+                            () => (_bufferedKey = System.Console.ReadKey(intercept: true)).Value);
+            }
+            finally
+            {
+                _readKeyHandle.Release();
+
+                // Throw if we're cancelled so the buffered key isn't cleared.
+                cancellationToken.ThrowIfCancellationRequested();
+                _bufferedKey = null;
+            }
+        }
+    }
+}

src/PowerShellEditorServices/Session/Host/EditorServicesPSHostUserInterface.cs

@@ -704,10 +704,11 @@ private async Task StartReplLoop(CancellationToken cancellationToken)
                         OutputType.Normal,
                         foregroundColor: ConsoleColor.Red);
                 }
+                // Do nothing here, the while loop condition will exit.
                 catch (TaskCanceledException)
-                {
-                    // Do nothing here, the while loop condition will exit.
-                }
+                { }
+                catch (OperationCanceledException)
+                { }
                 catch (Exception e) // Narrow this if possible
                 {
                     this.WriteOutput(