Improve pooling mechanism

src/UniTask.NetCoreSandbox/AllocationCheck.cs

@@ -29,7 +29,12 @@ public class AllocationCheck
     {
         for (int i = 0; i < InnerOps; i++)
         {
-            await Core();
+            var a = Core();
+            var b = Core();
+            var c = Core();
+            await a;
+            await b;
+            await c;
         }
 
         static async UniTask Core()
@@ -46,7 +51,12 @@ public class AllocationCheck
         var sum = 0;
         for (int i = 0; i < InnerOps; i++)
         {
-            sum += await Core();
+            var a = Core();
+            var b = Core();
+            var c = Core();
+            sum += await a;
+            sum += await b;
+            sum += await c;
         }
         return sum;
 
@@ -59,14 +69,16 @@ public class AllocationCheck
         }
     }
 
-    [Benchmark(OperationsPerInvoke = InnerOps)]
-    public Task ViaUniTaskVoid()
+    //[Benchmark(OperationsPerInvoke = InnerOps)]
+    //[Benchmark]
+    public void ViaUniTaskVoid()
     {
         for (int i = 0; i < InnerOps; i++)
         {
             Core().Forget();
+            Core().Forget();
+            Core().Forget();
         }
-        return Task.CompletedTask;
 
         static async UniTaskVoid Core()
         {
@@ -75,6 +87,46 @@ public class AllocationCheck
             await new TestAwaiter(false, UniTaskStatus.Succeeded);
         }
     }
+
+    struct Foo : IAsyncStateMachine
+    {
+        public AsyncUniTaskVoidMethodBuilder builder;
+        public TestAwaiter awaiter;
+        public TestAwaiter awaiterawaiter;
+
+        public int state;
+
+        public void MoveNext()
+        {
+            switch (state)
+            {
+                case -1:
+                    awaiterawaiter = awaiter.GetAwaiter();
+                    if (awaiterawaiter.IsCompleted)
+                    {
+                        goto case 0;
+                    }
+                    else
+                    {
+                        state = 0;
+                        builder.AwaitUnsafeOnCompleted(ref awaiterawaiter, ref this);
+                        return;
+                    }
+
+                case 0:
+                default:
+                    goto END;
+            }
+
+            END:
+            builder.SetResult();
+        }
+
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+
+        }
+    }
 }
 
 public class TaskTestException : Exception
@@ -170,7 +222,15 @@ public struct TestAwaiter<T> : ICriticalNotifyCompletion
 
 public sealed class ThreadPoolWorkItem : IThreadPoolWorkItem
 {
-    static readonly ConcurrentQueue<ThreadPoolWorkItem> pool = new ConcurrentQueue<ThreadPoolWorkItem>();
+    public static readonly ConcurrentQueue<ThreadPoolWorkItem> pool = new ConcurrentQueue<ThreadPoolWorkItem>();
+
+    public static void CreatePoolItems(int count)
+    {
+        for (int i = 0; i < count; i++)
+        {
+            pool.Enqueue(new ThreadPoolWorkItem());
+        }
+    }
 
     Action continuation;
 

src/UniTask.NetCoreSandbox/Benchmark.cs

@@ -37,7 +37,7 @@ public class BenchmarkConfig : ManualConfig
     public BenchmarkConfig()
     {
         AddDiagnoser(MemoryDiagnoser.Default);
-        AddJob(Job.ShortRun.WithLaunchCount(1).WithIterationCount(1).WithWarmupCount(1));
+        AddJob(Job.ShortRun.WithLaunchCount(1).WithIterationCount(1).WithWarmupCount(1)/*.RunOncePerIteration()*/);
     }
 }
 

src/UniTask.NetCoreSandbox/Program.cs

@@ -198,12 +198,15 @@ namespace NetCoreSandbox
         static async Task Main(string[] args)
         {
 #if !DEBUG
+            
+            //await new AllocationCheck().ViaUniTaskVoid();
+            //Console.ReadLine();
             BenchmarkDotNet.Running.BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
 
             //await new ComparisonBenchmarks().ViaUniTaskT();
             return;
 #endif
-
+            // await new AllocationCheck().ViaUniTaskVoid();
 
             // AsyncTest().Forget();
 
@@ -212,24 +215,43 @@ namespace NetCoreSandbox
 
             // AsyncTest().Forget();
 
+            ThreadPool.SetMinThreads(100, 100);
+
+            List<UniTask<int>> list = new List<UniTask<int>>();
+            for (int i = 0; i < 321; i++)
+            {
+                list.Add(AsyncTest());
+            }
+            //await UniTask.WhenAll(list);
+
+            Console.WriteLine("TOGO");
+
+            var a = await AsyncTest();
+            var b = AsyncTest();
+            var c = AsyncTest();
+
+            await b;
+            await c;
+
+
+            foreach (var item in Cysharp.Threading.Tasks.Internal.StackNodeMonitor.GetCacheSizeInfo())
+            {
+                Console.WriteLine(item);
+            }
 
-            await UniTask.Yield();
             Console.ReadLine();
         }
 
 #pragma warning disable CS1998
 
 
-        static async UniTaskVoid AsyncTest()
+        static async UniTask<int> AsyncTest()
         {
-            // empty
+            // empty 
             await new TestAwaiter(false, UniTaskStatus.Succeeded);
             await new TestAwaiter(true, UniTaskStatus.Succeeded);
             await new TestAwaiter(false, UniTaskStatus.Succeeded);
-
-
-            Console.WriteLine("foo");
-            //return 10;
+            return 10;
         }