Begin to reduce parsing allocations

Author: Kaliumhexacyanoferrat

Engine/Protocol/RequestBuilder.cs

@@ -88,9 +88,9 @@ public RequestBuilder Protocol(string version)
             return this;
         }
 
-        public RequestBuilder Type(string type)
+        public RequestBuilder Type(FlexibleRequestMethod type)
         {
-            _RequestMethod = FlexibleRequestMethod.Get(type);
+            _RequestMethod = type;
             return this;
         }
 

Engine/Protocol/RequestParser.cs

@@ -1,16 +1,14 @@
-using System;
+using GenHTTP.Api.Protocol;
+using GenHTTP.Api.Routing;
+using GenHTTP.Engine.Infrastructure.Configuration;
+using PooledAwait;
+using System;
 using System.Buffers;
 using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
-using GenHTTP.Api.Protocol;
-using GenHTTP.Api.Routing;
-
-using GenHTTP.Engine.Infrastructure.Configuration;
-using PooledAwait;
-
 namespace GenHTTP.Engine.Protocol
 {
 
@@ -29,6 +27,8 @@ internal sealed class RequestParser
         private static readonly char[] LINE_ENDING = new char[] { '\r' };
         private static readonly char[] PATH_ENDING = new char[] { '\r', '\n', '?', ' ' };
 
+        private static readonly string[] KNOWN_HEADERS = new[] { "Host", "User-Agent", "Accept" };
+
         private static readonly Encoding ASCII = Encoding.ASCII;
 
         private RequestBuilder? _Builder;
@@ -52,14 +52,16 @@ internal RequestParser(NetworkConfiguration configuration)
 
         #region Functionality
 
-        internal async ValueTask<RequestBuilder?> TryParseAsync(RequestBuffer buffer)
+        internal async PooledValueTask<RequestBuilder?> TryParseAsync(RequestBuffer buffer)
         {
             WebPath? path;
             RequestQuery? query;
 
-            string? method, protocol;
+            FlexibleRequestMethod? method;
 
-            if ((method = await ReadToken(buffer, ' ').ConfigureAwait(false)) is not null)
+            string? protocol;
+
+            if ((method = await TryReadMethod(buffer)) is not null)
             {
                 Request.Type(method);
             }
@@ -82,7 +84,7 @@ internal RequestParser(NetworkConfiguration configuration)
                 Request.Query(query);
             }
 
-            if ((protocol = await ReadToken(buffer, '\r', 1, 5)) is not null)
+            if ((protocol = await TryReadProtocolVersion(buffer)) is not null)
             {
                 Request.Protocol(protocol);
             }
@@ -121,6 +123,49 @@ internal RequestParser(NetworkConfiguration configuration)
             return result;
         }
 
+        private static async PooledValueTask<FlexibleRequestMethod?> TryReadMethod(RequestBuffer buffer)
+        {
+            if (await FindPosition(buffer, ' ').ConfigureAwait(false) is null)
+            {
+                return null;
+            }
+
+            if (CompareTo(buffer, "GET", 1)) return FlexibleRequestMethod.Get(RequestMethod.GET);
+
+            var token = await ReadToken(buffer, ' ');
+
+            if (token is not null)
+            {
+                return FlexibleRequestMethod.Get(token);
+            }
+
+            return null;
+        }
+
+        private static async PooledValueTask<string?> TryReadProtocolVersion(RequestBuffer buffer)
+        {
+            // skip the "HTTP/" part
+            buffer.Advance(5);
+
+            if (await FindPosition(buffer, '\r').ConfigureAwait(false) is null)
+            {
+                return null;
+            }
+
+            if (CompareTo(buffer, "1.1", 2))
+            {
+                return "1.1";
+            }
+            else if (CompareTo(buffer, "1.0", 2))
+            {
+                return "1.0";
+            }
+            else
+            {
+                return null;
+            }
+        }
+
         private static async ValueTask<WebPath?> TryReadPath(RequestBuffer buffer)
         {
             // ignore the slash at the beginning
@@ -180,41 +225,31 @@ private static async ValueTask<bool> TryReadHeader(RequestBuffer buffer, Request
         {
             string? key, value;
 
-            if ((key = await ReadToken(buffer, ':', 1).ConfigureAwait(false)) is not null)
+            if (await FindPosition(buffer, ':').ConfigureAwait(false) is not null) 
             {
-                if ((value = await ReadToken(buffer, '\r', 1)) is not null)
+                foreach (var knownHeader in KNOWN_HEADERS)
                 {
-                    request.Header(key, value);
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        private static async PooledValueTask<SequencePosition?> FindPosition(RequestBuffer buffer, char delimiter)
-        {
-            if (buffer.ReadRequired)
-            {
-                if ((await buffer.Read().ConfigureAwait(false)) is null)
-                {
-                    return null;
+                    if (CompareTo(buffer, knownHeader, 2))
+                    {
+                        if ((value = await ReadToken(buffer, '\r', 1)) is not null)
+                        {
+                            request.Header(knownHeader, value);
+                            return true;
+                        }
+                    }
                 }
-            }
-
-            var position = buffer.Data.PositionOf((byte)delimiter);
 
-            if (position is null)
-            {
-                if ((await buffer.Read(true).ConfigureAwait(false)) is null)
+                if ((key = await ReadToken(buffer, ':', 1)) is not null)
                 {
-                    return null;
+                    if ((value = await ReadToken(buffer, '\r', 1)) is not null)
+                    {
+                        request.Header(key, value);
+                        return true;
+                    }
                 }
-
-                position = buffer.Data.PositionOf((byte)delimiter);
             }
 
-            return position;
+            return false;
         }
 
         private static ValueTask<string?> ReadToken(RequestBuffer buffer, char delimiter, ushort skipNext = 0, ushort skipFirst = 0, bool skipDelimiter = true)
@@ -268,6 +303,57 @@ private static async ValueTask<bool> TryReadHeader(RequestBuffer buffer, Request
             return null;
         }
 
+        private static bool CompareTo(RequestBuffer buffer, string expected, ushort skipNext = 0)
+        {
+            var i = 0;
+
+            var slice = buffer.Data.Slice(0, expected.Length);
+
+            if (slice.Length != expected.Length)
+            {
+                return false;
+            }
+
+            foreach (var segment in slice)
+            {
+                for (int j = 0; j < segment.Length; j++)
+                {
+                    if (segment.Span[j] != expected[i++])
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            buffer.Advance(expected.Length + skipNext);
+            return true;
+        }
+
+        private static async PooledValueTask<SequencePosition?> FindPosition(RequestBuffer buffer, char delimiter)
+        {
+            if (buffer.ReadRequired)
+            {
+                if ((await buffer.Read().ConfigureAwait(false)) is null)
+                {
+                    return null;
+                }
+            }
+
+            var position = buffer.Data.PositionOf((byte)delimiter);
+
+            if (position is null)
+            {
+                if ((await buffer.Read(true).ConfigureAwait(false)) is null)
+                {
+                    return null;
+                }
+
+                position = buffer.Data.PositionOf((byte)delimiter);
+            }
+
+            return position;
+        }
+
         private static string GetString(ReadOnlySequence<byte> buffer)
         {
             return string.Create((int)buffer.Length, buffer, (span, sequence) =>

Modules/ClientCaching/Validation/CacheValidationHandler.cs

@@ -14,6 +14,8 @@ public sealed class CacheValidationHandler : IConcern
     {
         private const string ETAG_HEADER = "ETag";
 
+        private static readonly RequestMethod[] _SupportedMethods = new[] { RequestMethod.GET, RequestMethod.HEAD };
+
         #region Get-/Setters
 
         public IHandler Parent { get; }
@@ -38,7 +40,7 @@ public CacheValidationHandler(IHandler parent, Func<IHandler, IHandler> contentF
         {
             var response = await Content.HandleAsync(request).ConfigureAwait(false);
 
-            if (request.HasType(RequestMethod.GET, RequestMethod.HEAD))
+            if (request.HasType(_SupportedMethods))
             {
                 if ((response is not null) && (response.Content is not null))
                 {

Playground/Program.cs

@@ -5,7 +5,8 @@
 
 Host.Create()
     .Handler(Content.From(Resource.FromString("Hello World")))
-    .Defaults()
-    .Development()
-    .Console()
-    .Run();
+    //.Defaults()
+    //.Development()
+    //.Console()
+    .Run();
+