Add Multithread perf test

test/Microsoft.AspNetCore.Server.Kestrel.Performance/MultiThreadedRequestParsing.cs

@@ -0,0 +1,192 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Microsoft.AspNetCore.Server.Kestrel.Internal.Http;
+using Microsoft.AspNetCore.Server.Kestrel.Internal.Infrastructure;
+using Microsoft.AspNetCore.Testing;
+using RequestLineStatus = Microsoft.AspNetCore.Server.Kestrel.Internal.Http.Frame.RequestLineStatus;
+
+namespace Microsoft.AspNetCore.Server.Kestrel.Performance
+{
+    [Config(typeof(CoreConfig))]
+    public class MultiThreadedRequestParsing
+    {
+        // Is divided by processor count so will be slightly off as the 
+        // LCM of Intel's core counts (22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2) is 55440 
+        // which would be far too many iterations
+        private const int InnerLoopCount = 4096;
+
+        private static readonly int ThreadCount = Environment.ProcessorCount;
+        private static readonly int LoopCount = InnerLoopCount / ThreadCount;
+
+        private static MemoryPool[] MemoryPool;
+        private static SocketInput[] Input;
+        private static Frame<object>[] Frame;
+
+        [Benchmark(Baseline = true, OperationsPerInvoke = InnerLoopCount)]
+        public void ParsePlaintext()
+        {
+            Parallel.For(0, ThreadCount, new ParallelOptions() {MaxDegreeOfParallelism = ThreadCount}, (index) =>
+            {
+                var socketInput = Input[index];
+                var frame = Frame[index];
+
+                for (var i = 0; i < LoopCount; i++)
+                {
+                    InsertData(socketInput, Requests.PlaintextRequest);
+
+                    ParseData(socketInput, frame);
+                }
+            });
+        }
+
+        [Benchmark(OperationsPerInvoke = InnerLoopCount * Requests.Pipelining)]
+        public void ParsePipelinedPlaintext()
+        {
+            Parallel.For(0, ThreadCount, new ParallelOptions() { MaxDegreeOfParallelism = ThreadCount }, (index) =>
+            {
+                var socketInput = Input[index];
+                var frame = Frame[index];
+
+                for (var i = 0; i < LoopCount; i++)
+                {
+                    InsertData(socketInput, Requests.PlaintextPipelinedRequests);
+
+                    ParseData(socketInput, frame);
+                }
+            });
+        }
+
+        [Benchmark(OperationsPerInvoke = InnerLoopCount)]
+        public void ParseLiveAspNet()
+        {
+            Parallel.For(0, ThreadCount, new ParallelOptions() { MaxDegreeOfParallelism = ThreadCount }, (index) =>
+            {
+                var socketInput = Input[index];
+                var frame = Frame[index];
+
+                for (var i = 0; i < LoopCount; i++)
+                {
+                    InsertData(socketInput, Requests.LiveAspNetRequest);
+
+                    ParseData(socketInput, frame);
+                }
+            });
+        }
+
+        [Benchmark(OperationsPerInvoke = InnerLoopCount * Requests.Pipelining)]
+        public void ParsePipelinedLiveAspNet()
+        {
+            Parallel.For(0, ThreadCount, new ParallelOptions() { MaxDegreeOfParallelism = ThreadCount }, (index) =>
+            {
+                var socketInput = Input[index];
+                var frame = Frame[index];
+
+                for (var i = 0; i < LoopCount; i++)
+                {
+                    InsertData(socketInput, Requests.LiveAspNetPipelinedRequests);
+
+                    ParseData(socketInput, frame);
+                }
+            });
+        }
+
+        [Benchmark(OperationsPerInvoke = InnerLoopCount)]
+        public void ParseUnicode()
+        {
+            Parallel.For(0, ThreadCount, new ParallelOptions() { MaxDegreeOfParallelism = ThreadCount }, (index) =>
+            {
+                var socketInput = Input[index];
+                var frame = Frame[index];
+
+                for (var i = 0; i < LoopCount; i++)
+                {
+                    InsertData(socketInput, Requests.UnicodeRequest);
+
+                    ParseData(socketInput, frame);
+                }
+            });
+        }
+
+        [Benchmark(OperationsPerInvoke = InnerLoopCount * Requests.Pipelining)]
+        public void ParseUnicodePipelined()
+        {
+            Parallel.For(0, ThreadCount, new ParallelOptions() { MaxDegreeOfParallelism = ThreadCount }, (index) =>
+            {
+                var socketInput = Input[index];
+                var frame = Frame[index];
+
+                for (var i = 0; i < LoopCount; i++)
+                {
+                    InsertData(socketInput, Requests.UnicodePipelinedRequests);
+
+                    ParseData(socketInput, frame);
+                }
+            });
+        }
+
+        private static void InsertData(SocketInput socketInput, byte[] dataBytes)
+        {
+            socketInput.IncomingData(dataBytes, 0, dataBytes.Length);
+        }
+
+        private static void ParseData(SocketInput socketInput, Frame<object> frame)
+        {
+            while (socketInput.GetAwaiter().IsCompleted)
+            {
+                frame.Reset();
+
+                if (frame.TakeStartLine(socketInput) != RequestLineStatus.Done)
+                {
+                    ThrowInvalidStartLine();
+                }
+
+                frame.InitializeHeaders();
+
+                if (!frame.TakeMessageHeaders(socketInput, (FrameRequestHeaders)frame.RequestHeaders))
+                {
+                    ThrowInvalidMessageHeaders();
+                }
+            }
+        }
+
+        private static void ThrowInvalidStartLine()
+        {
+            throw new InvalidOperationException("Invalid StartLine");
+        }
+
+        private static void ThrowInvalidMessageHeaders()
+        {
+            throw new InvalidOperationException("Invalid MessageHeaders");
+        }
+
+        [Setup]
+        public void Setup()
+        {
+            var threadCount = ThreadCount;
+
+            MemoryPool = new MemoryPool[threadCount];
+            Input = new SocketInput[threadCount];
+            Frame = new Frame<object>[threadCount];
+
+            for (var i = 0; i < threadCount; i++)
+            {
+                Requests.SetupFrameObjects(out MemoryPool[i], out Input[i], out Frame[i]);
+            }
+
+        }
+
+        [Cleanup]
+        public void Cleanup()
+        {
+            var threadCount = ThreadCount;
+            for (var i = 0; i < threadCount; i++)
+            {
+                Requests.CleanUpFrameObjects(ref MemoryPool[i], ref Input[i], ref Frame[i]);
+            }
+        }
+    }
+}

test/Microsoft.AspNetCore.Server.Kestrel.Performance/Program.cs

@@ -2,18 +2,15 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using BenchmarkDotNet.Environments;
-using BenchmarkDotNet.Jobs;
-using BenchmarkDotNet.Properties;
 using BenchmarkDotNet.Running;
-using BenchmarkDotNet.Toolchains;
 
 namespace Microsoft.AspNetCore.Server.Kestrel.Performance
 {
     public class Program
     {
         public static void Main(string[] args)
         {
+            Console.WriteLine($"Kestrel.Performance Tests - ProcessorCount: {Environment.ProcessorCount.ToString()}");
             var options = (uint[])Enum.GetValues(typeof(BenchmarkType));
             BenchmarkType type;
             if (args.Length != 1 || !Enum.TryParse(args[0], out type))
@@ -36,13 +33,18 @@ private static void RunSelectedBenchmarks(BenchmarkType type)
             {
                 BenchmarkRunner.Run<RequestParsing>();
             }
+            if (type.HasFlag(BenchmarkType.MultiThreadedRequestParsing))
+            {
+                BenchmarkRunner.Run<MultiThreadedRequestParsing>();
+            }
         }
     }
 
     [Flags]
     public enum BenchmarkType : uint
     {
         RequestParsing = 1,
+        MultiThreadedRequestParsing = 2,
         // add new ones in powers of two - e.g. 2,4,8,16...
 
         All = uint.MaxValue

test/Microsoft.AspNetCore.Server.Kestrel.Performance/Readme.md

@@ -3,6 +3,7 @@
 To run a specific benchmark add it as parameter
 ```
 dotnet run RequestParsing
+dotnet run MultiThreadedRequestParsing
 ```
 To run all use `All` as parameter
 ```