aa

frameworks/C/nginx/nginx.dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:21.04
+FROM ubuntu:20.10
 
 ARG DEBIAN_FRONTEND=noninteractive
 

frameworks/CSharp/appmpower/src/Db/PooledConnections.cs

@@ -7,64 +7,67 @@ namespace appMpower.Db
 {
    public static class PooledConnections
    {
-      private static int _maxLoops = 999;
+      private static bool _connectionsCreated = false;
       private static byte _createdConnections = 0;
       private static byte _maxConnections = Math.Min((byte)Environment.ProcessorCount, (byte)21);
       private static ConcurrentStack<PooledConnection> _stack = new ConcurrentStack<PooledConnection>();
+      private static ConcurrentQueue<TaskCompletionSource<PooledConnection>> _waitingQueue = new ConcurrentQueue<TaskCompletionSource<PooledConnection>>();
 
       public static async Task<PooledConnection> GetConnection(string connectionString)
       {
-         int i = 0;
-         PooledConnection pooledConnection;
+         PooledConnection pooledConnection = null;
 
-         if (_createdConnections < _maxConnections)
+         if (_connectionsCreated)
+         {
+            if (!_stack.TryPop(out pooledConnection))
+            {
+               pooledConnection = await GetPooledConnectionAsync();
+            }
+
+            return pooledConnection;
+
+         }
+         else
          {
             pooledConnection = new PooledConnection();
             pooledConnection.OdbcConnection = new OdbcConnection(connectionString);
             _createdConnections++;
+
+            if (_createdConnections == _maxConnections) _connectionsCreated = true;
+
             pooledConnection.Number = _createdConnections;
             pooledConnection.PooledCommands = new ConcurrentDictionary<string, PooledCommand>();
             //Console.WriteLine("opened connection number: " + pooledConnection.Number);
 
             return pooledConnection;
          }
-         else
-         {
-            while (!_stack.TryPop(out pooledConnection) && i < _maxLoops)
-            {
-               if (i < 5) await Task.Delay(1);
-               else if (i < 10) await Task.Delay(2);
-               else if (i < 25) await Task.Delay(3);
-               else if (i < 50) await Task.Delay(4);
-               else if (i < 100) await Task.Delay(5);
-               else if (i < 500) await Task.Delay(10);
-               else await Task.Delay(20);
+      }
 
-               i++;
-               //Console.WriteLine("waiting: " + i);
-            }
+      public static Task<PooledConnection> GetPooledConnectionAsync()
+      {
+         var taskCompletionSource = new TaskCompletionSource<PooledConnection>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            if (i < _maxLoops)
-            {
-               //Console.WriteLine("opened connection number: " + pooledConnection.Number);
-               return pooledConnection;
-            }
-            else
-            {
-               throw new Exception("No connections are available");
-            }
-         }
+         _waitingQueue.Enqueue(taskCompletionSource);
+         return taskCompletionSource.Task;
       }
 
       public static void ReleaseConnection(PooledConnection pooledConnection)
       {
+         TaskCompletionSource<PooledConnection> taskCompletionSource;
          PooledConnection stackedConnection = new PooledConnection();
 
          stackedConnection.OdbcConnection = pooledConnection.OdbcConnection;
          stackedConnection.Number = pooledConnection.Number;
          stackedConnection.PooledCommands = pooledConnection.PooledCommands;
 
-         _stack.Push(stackedConnection);
+         if (_waitingQueue.TryDequeue(out taskCompletionSource))
+         {
+            taskCompletionSource.SetResult(stackedConnection);
+         }
+         else
+         {
+            _stack.Push(stackedConnection);
+         }
       }
    }
 }

frameworks/CSharp/appmpower/src/HttpApplication.cs

@@ -1,16 +1,16 @@
 using System;
+using System.Text;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Hosting.Server;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
 using appMpower.Kestrel;
-using PlatformBenchmarks;
 
 namespace appMpower
 {
    public class HttpApplication : IHttpApplication<IFeatureCollection>
    {
-      private readonly static AsciiString _plainText = "Hello, World!";
+      public static readonly byte[] _plainText = Encoding.UTF8.GetBytes("Hello, World!");
       private readonly static JsonMessageSerializer _jsonMessageSerializer = new JsonMessageSerializer();
       private readonly static WorldSerializer _worldSerializer = new WorldSerializer();
 
@@ -34,7 +34,7 @@ public async Task ProcessRequestAsync(IFeatureCollection featureCollection)
 
             if (pathStringLength == 10 && pathStringStart == "p")
             {
-               PlainText.Render(httpResponse.Headers, httpResponseBody.Writer, _plainText);
+               await PlainText.RenderAsync(httpResponse.Headers, httpResponseBody.Writer, _plainText);
                return;
             }
             else if (pathStringLength == 5 && pathStringStart == "j")

frameworks/CSharp/appmpower/src/Kestrel/PlainText.cs

@@ -1,8 +1,9 @@
+using System;
+using System.Threading.Tasks;
 using System.Collections.Generic;
 using System.IO.Pipelines;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
-using PlatformBenchmarks;
 
 namespace appMpower.Kestrel
 {
@@ -13,15 +14,16 @@ public static class PlainText
       private readonly static KeyValuePair<string, StringValues> _headerContentType =
          new KeyValuePair<string, StringValues>("Content-Type", new StringValues("text/plain"));
 
-      public static void Render(IHeaderDictionary headerDictionary, PipeWriter pipeWriter, AsciiString utf8String)
+      public static async Task<FlushResult> RenderAsync(IHeaderDictionary headerDictionary, PipeWriter pipeWriter, ReadOnlyMemory<byte> utf8String)
       {
          headerDictionary.Add(_headerServer);
          headerDictionary.Add(_headerContentType);
          headerDictionary.Add(new KeyValuePair<string, StringValues>("Content-Length", utf8String.Length.ToString()));
 
-         var bufferWriter = new BufferWriter<WriterAdapter>(new WriterAdapter(pipeWriter), 208);
-         bufferWriter.Write(utf8String);
-         bufferWriter.Commit();
+         var result = await pipeWriter.WriteAsync(utf8String);
+         await pipeWriter.FlushAsync();
+
+         return result;
       }
    }
 }

frameworks/CSharp/beetlex/Benchmarks/Benchmarks.csproj

@@ -6,7 +6,7 @@
     <ServerGarbageCollection>true</ServerGarbageCollection>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="BeetleX.FastHttpApi" Version="1.5.2.6" />
+    <PackageReference Include="BeetleX.FastHttpApi" Version="1.9.6" />
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="5.0.0" />
     <PackageReference Include="Npgsql" Version="5.0.0-alpha1" />
     <PackageReference Include="SpanJson" Version="3.0.1" />

frameworks/CSharp/beetlex/Benchmarks/Program.cs

@@ -84,33 +84,34 @@ public class BeetleXHttpServer : IHostedService
 
         private HttpApiServer mApiServer;
 
+        private System.Threading.Tasks.TaskCompletionSource<object> mComplete = new TaskCompletionSource<object>();
+
         public async virtual Task StartAsync(CancellationToken cancellationToken)
         {
+
+
             plaintextResult = new StringBytes(_helloWorldPayload);
             mApiServer = new HttpApiServer();
             mApiServer.Options.Port = 8080;
             mApiServer.Options.BufferPoolMaxMemory = 500;
             mApiServer.Options.MaxConnections = 100000;
             mApiServer.Options.Statistical = false;
-            mApiServer.Options.UrlIgnoreCase = false;
             mApiServer.Options.LogLevel = BeetleX.EventArgs.LogType.Error;
             mApiServer.Options.LogToConsole = true;
-            mApiServer.Options.PrivateBufferPool = true;
             mApiServer.Register(typeof(Program).Assembly);
             HeaderTypeFactory.SERVAR_HEADER_BYTES = Encoding.ASCII.GetBytes("Server: TFB\r\n");
             mApiServer.HttpConnected += (o, e) =>
             {
                 e.Session["DB"] = new RawDb(new ConcurrentRandom(), Npgsql.NpgsqlFactory.Instance);
             };
+            mApiServer.Started += (o, e) =>
+            {
+                mComplete.TrySetResult(new object());
+            };
             mApiServer.Open();
             RawDb._connectionString = "Server=tfb-database;Database=hello_world;User Id=benchmarkdbuser;Password=benchmarkdbpass;Maximum Pool Size=256;NoResetOnClose=true;Enlist=false;Max Auto Prepare=4;Multiplexing=true;Write Coalescing Delay Us=500;Write Coalescing Buffer Threshold Bytes=1000";
             //RawDb._connectionString = "Server=192.168.2.19;Database=hello_world;User Id=benchmarkdbuser;Password=benchmarkdbpass;Maximum Pool Size=256;NoResetOnClose=true;Enlist=false;Max Auto Prepare=3";
-            System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
-            var response = await client.GetAsync("http://localhost:8080/json");
-            mApiServer.BaseServer.Log(LogType.Info, null, $"Get josn {response.StatusCode}");
-            response = await client.GetAsync("http://localhost:8080/plaintext");
-            mApiServer.BaseServer.Log(LogType.Info, null, $"Get plaintext {response.StatusCode}");
-
+            await mComplete.Task;
         }
 
         public virtual Task StopAsync(CancellationToken cancellationToken)

frameworks/CSharp/beetlex/PlatformBenchmarks/AsciiString.cs

@@ -8,96 +8,52 @@ namespace PlatformBenchmarks
     {
         private readonly byte[] _data;
 
-        public byte[] Data => _data;
-
-        public int Length => _data.Length;
-
-        public AsciiString(string s)
-        {
-            _data = Encoding.ASCII.GetBytes(s);
-        }
+        public AsciiString(string s) => _data = Encoding.ASCII.GetBytes(s);
 
-        public ReadOnlySpan<byte> AsSpan()
-        {
-            return _data;
-        }
+        private AsciiString(byte[] b) => _data = b;
 
-        public static implicit operator ReadOnlySpan<byte>(AsciiString str)
-        {
-            return str._data;
-        }
-
-        public static implicit operator byte[](AsciiString str)
-        {
-            return str._data;
-        }
-
-        public static implicit operator AsciiString(string str)
-        {
-            return new AsciiString(str);
-        }
+        public int Length => _data.Length;
 
-        public override string ToString()
-        {
-            return Encoding.ASCII.GetString(_data);
-        }
+        public byte[] Data => _data;
 
-        public int CopyTo(byte[] source,int offset)
-        {
-            var len = Length;
-            Buffer.BlockCopy(_data, 0, source, offset, len);
-            return len;
-        }
+        public ReadOnlySpan<byte> AsSpan() => _data;
 
-        public static explicit operator string(AsciiString str)
-        {
-            return str.ToString();
-        }
+        public static implicit operator ReadOnlySpan<byte>(AsciiString str) => str._data;
+        public static implicit operator byte[](AsciiString str) => str._data;
 
-        public bool Equals(AsciiString other)
-        {
-            if (_data != other._data)
-            {
-                return SequenceEqual(_data, other._data);
-            }
-            return true;
-        }
+        public static implicit operator AsciiString(string str) => new AsciiString(str);
 
-        private bool SequenceEqual(byte[] data1, byte[] data2)
-        {
-            return new Span<byte>(data1).SequenceEqual(data2);
-        }
+        public override string ToString() => Encoding.ASCII.GetString(_data);
+        public static explicit operator string(AsciiString str) => str.ToString();
 
-        public static bool operator ==(AsciiString a, AsciiString b)
-        {
-            return a.Equals(b);
-        }
+        public bool Equals(AsciiString other) => ReferenceEquals(_data, other._data) || SequenceEqual(_data, other._data);
+        private bool SequenceEqual(byte[] data1, byte[] data2) => new Span<byte>(data1).SequenceEqual(data2);
 
-        public static bool operator !=(AsciiString a, AsciiString b)
-        {
-            return !a.Equals(b);
-        }
+        public static bool operator ==(AsciiString a, AsciiString b) => a.Equals(b);
+        public static bool operator !=(AsciiString a, AsciiString b) => !a.Equals(b);
+        public override bool Equals(object other) => (other is AsciiString) && Equals((AsciiString)other);
 
-        public override bool Equals(object other)
+        public static AsciiString operator +(AsciiString a, AsciiString b)
         {
-            if (other is AsciiString)
-            {
-                return Equals((AsciiString)other);
-            }
-            return false;
+            var result = new byte[a.Length + b.Length];
+            a._data.CopyTo(result, 0);
+            b._data.CopyTo(result, a.Length);
+            return new AsciiString(result);
         }
 
         public override int GetHashCode()
         {
-            byte[] data = _data;
-            int hash3 = 5381;
-            int hash2 = hash3;
-            byte[] array = data;
-            foreach (int b in array)
+            // Copied from x64 version of string.GetLegacyNonRandomizedHashCode()
+            // https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/String.Comparison.cs
+            var data = _data;
+            int hash1 = 5381;
+            int hash2 = hash1;
+            foreach (int b in data)
             {
-                hash3 = (((hash3 << 5) + hash3) ^ b);
+                hash1 = ((hash1 << 5) + hash1) ^ b;
             }
-            return hash3 + hash2 * 1566083941;
+            return hash1 + (hash2 * 1566083941);
         }
+
     }
 }