Use synchronous APIs on Full Framework + Windows Arm.

Author: timcassell

src/BenchmarkDotNet/Helpers/CancelableStreamReader.cs

@@ -1,4 +1,5 @@
-using System;
+using BenchmarkDotNet.Extensions;
+using System;
 using System.Buffers;
 using System.Buffers.Binary;
 using System.Diagnostics;
@@ -14,23 +15,28 @@ namespace BenchmarkDotNet.Helpers;
 internal sealed class CancelableStreamReader : IDisposable
 {
 #if NET7_0_OR_GREATER
-    private readonly StreamReader _reader;
+    private readonly StreamReader _defaultReader;
 
     public CancelableStreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize = -1, bool leaveOpen = false)
-        => _reader = new(stream, encoding, detectEncodingFromByteOrderMarks, bufferSize, leaveOpen);
+        => _defaultReader = new(stream, encoding, detectEncodingFromByteOrderMarks, bufferSize, leaveOpen);
 
     public ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken)
-        => _reader.ReadLineAsync(cancellationToken);
+        => _defaultReader.ReadLineAsync(cancellationToken);
 
     public void Dispose()
-        => _reader.Dispose();
+        => _defaultReader.Dispose();
 #else
     // Impl copied from https://github.com/dotnet/runtime/blob/407f9f1476709c3e5aea25511b330e5c1df13fb8/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs
     // slightly adjusted to work in netstandard2.0.
 
     private const int DefaultBufferSize = 1024;
     private const int MinBufferSize = 128;
 
+    // Full Framework on Windows Arm runs on a compatibility layer rather than native.
+    // This difference was observed to cause hangs with async stream APIs over TcpClient that doesn't happen on other native supported environments.
+    // In that environment we change the async read to the default sync read via Task.Run.
+    private readonly StreamReader _defaultReader;
+
     private readonly Stream _stream;
     private Encoding _encoding;
     private Decoder _decoder;
@@ -51,6 +57,18 @@ public CancelableStreamReader(Stream stream, Encoding encoding, bool detectEncod
         if (stream == null) throw new ArgumentNullException(nameof(stream));
         if (!stream.CanRead) throw new ArgumentException("Stream is not readable", nameof(stream));
 
+        if (Portability.RuntimeInformation.IsFullFrameworkCompatibilityLayer)
+        {
+            _defaultReader = new(stream, encoding, detectEncodingFromByteOrderMarks, bufferSize < 0 ? DefaultBufferSize : bufferSize, leaveOpen);
+            _closable = true;
+            _stream = null!;
+            _encoding = null!;
+            _decoder = null!;
+            _byteBuffer = null!;
+            _charBuffer = null!;
+            return;
+        }
+
         if (bufferSize == -1)
         {
             bufferSize = DefaultBufferSize;
@@ -74,6 +92,7 @@ public CancelableStreamReader(Stream stream, Encoding encoding, bool detectEncod
         _checkPreamble = preambleLength > 0 && preambleLength <= bufferSize;
 
         _closable = !leaveOpen;
+        _defaultReader = null!;
     }
 
     ~CancelableStreamReader()
@@ -99,7 +118,14 @@ private void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    _stream.Close();
+                    if (Portability.RuntimeInformation.IsFullFrameworkCompatibilityLayer)
+                    {
+                        _defaultReader.Dispose();
+                    }
+                    else
+                    {
+                        _stream.Close();
+                    }
                 }
             }
             finally
@@ -112,6 +138,12 @@ private void Dispose(bool disposing)
 
     public async ValueTask<string?> ReadLineAsync(CancellationToken cancellationToken)
     {
+        if (Portability.RuntimeInformation.IsFullFrameworkCompatibilityLayer)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return await Task.Run(() => _defaultReader.ReadLine(), cancellationToken).WaitAsync(cancellationToken);
+        }
+
         if (_charPos == _charLen && (await ReadBufferAsync(cancellationToken).ConfigureAwait(false)) == 0)
         {
             return null;

src/BenchmarkDotNet/Loggers/Broker.cs

@@ -94,7 +94,9 @@ private async ValueTask<Result> ProcessDataCore()
                 }
                 using var _ = client;
 #else
-                using var client = await tcpListener.AcceptTcpClientAsync().WaitAsync(TcpHost.ConnectionTimeout, cancellationTokenSource.Token);
+                using var client = Portability.RuntimeInformation.IsFullFrameworkCompatibilityLayer
+                    ? await Task.Run(() => tcpListener.AcceptTcpClient(), cancellationTokenSource.Token).WaitAsync(TcpHost.ConnectionTimeout, cancellationTokenSource.Token)
+                    : await tcpListener.AcceptTcpClientAsync().WaitAsync(TcpHost.ConnectionTimeout, cancellationTokenSource.Token);
 #endif
                 using var stream = client.GetStream();
                 using CancelableStreamReader reader = new(stream, TcpHost.UTF8NoBOM, detectEncodingFromByteOrderMarks: false);

src/BenchmarkDotNet/Portability/RuntimeInformation.cs

@@ -45,6 +45,8 @@ internal static class RuntimeInformation
             FrameworkDescription.StartsWith(".NET Framework", StringComparison.OrdinalIgnoreCase);
 #endif
 
+        public static readonly bool IsFullFrameworkCompatibilityLayer = IsFullFramework && GetCurrentPlatform() is not (Platform.X86 or Platform.X64);
+
         [SupportedOSPlatformGuard("browser")]
 #if NET6_0_OR_GREATER
         public static readonly bool IsWasm = OperatingSystem.IsBrowser();