Perf Thoughts

.gitignore

@@ -83,6 +83,9 @@ user-token.json
 /cli/tests/bin/
 /cli/tests/obj/
 /cli/tests/.idea/
+/cli/benchmarks/bin/
+/cli/benchmarks/obj/
+/cli/benchmarks/.idea/
 /cli/*.sln.DotSettings.*
 cli/cli/beamoLocalRuntime.json
 

cli/Benchmarks/Benchmarks.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <OutputType>Exe</OutputType>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="BenchmarkDotNet" Version="0.13.12" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\beamable.common\beamable.common.csproj" />
+    </ItemGroup>
+
+</Project>

cli/Benchmarks/DependencyProviderBenchmarks.cs

@@ -0,0 +1,67 @@
+using Beamable.Common.Dependencies;
+using BenchmarkDotNet.Attributes;
+using System.Collections.Concurrent;
+
+namespace Benchmarks;
+
+[MemoryDiagnoser]
+[ShortRunJob]
+public class DependencyProviderBenchmarks
+{
+	// [Benchmark]
+	// public void JustAService()
+	// {
+	// 	var x = new ServiceDescriptor();
+	// }
+	// [Benchmark]
+	// public void Dict_Concurrent()
+	// {
+	// 	var x = new ConcurrentDictionary<Type, ServiceDescriptor>();
+	// }
+	// [Benchmark]
+	// public void Dict_Regular()
+	// {
+	// 	var x = new Dictionary<Type, ServiceDescriptor>();
+	// }
+
+	// [Benchmark]
+	public void BaseCase_JustProvider()
+	{
+		var provider = new DependencyProvider(null, null);
+	}
+
+	[Benchmark]
+	public void BaseCase_NoDispose()
+	{
+		var builder = new DependencyBuilder();
+		// builder.AddSingleton<TestService>();
+		var provider = builder.Build();
+
+		// var service = provider.GetService<TestService>();
+	}
+	//
+	// [Benchmark]
+	public void BaseCase_NoDispose_RegisterAndResolve()
+	{
+		var builder = new DependencyBuilder();
+		// builder.AddSingleton<TestService>();
+		var provider = builder.Build();
+		// var service = provider.GetService<TestService>();
+		// var serv = new TestService();
+	}
+	//
+	//
+	[Benchmark]
+	public void BaseCase_Dispose()
+	{
+		var builder = new DependencyBuilder();
+		var provider = builder.Build();
+		provider.Dispose();
+	}
+
+
+	public class TestService
+	{
+
+	}
+}

cli/Benchmarks/MultiThreadedAccessBenchmarks.cs

@@ -0,0 +1,37 @@
+using Beamable.Common.Dependencies;
+using BenchmarkDotNet.Attributes;
+
+namespace Benchmarks;
+
+[MemoryDiagnoser]
+[ShortRunJob]
+public class MultiThreadedAccessBenchmarks
+{
+	[Benchmark]
+	public async Task SingletonOnlyGetsMadeOnce()
+	{
+		var builder = new DependencyBuilder();
+		int count = 0;
+		builder.AddSingleton<A>(_ =>
+		{
+			count++;
+			return new A();
+		});
+		var provider = builder.Build();
+
+		var tasks = Enumerable.Range(0, 10_000).Select(i => Task.Run(async () =>
+		{
+			await Task.Delay(1);
+			provider.GetService<A>();
+		}));
+
+		await Task.WhenAll(tasks);
+
+
+	}
+
+	public class A
+	{
+		// no-op class just for testing
+	}
+}

cli/Benchmarks/Program.cs

@@ -0,0 +1,14 @@
+using BenchmarkDotNet.Running;
+
+namespace Benchmarks;
+
+public class Program
+{
+	public static void Main(string[] args)
+	{
+		// BenchmarkRunner.Run<MultiThreadedAccessBenchmarks>();
+		BenchmarkRunner.Run<DependencyProviderBenchmarks>();
+		// BenchmarkRunner.Run<PromiseBenchmarks>();
+
+	}
+}

cli/Benchmarks/PromiseBenchmarks.cs

@@ -0,0 +1,94 @@
+using Beamable.Common;
+using BenchmarkDotNet.Attributes;
+using System.Runtime.InteropServices.JavaScript;
+
+namespace Benchmarks;
+
+[MemoryDiagnoser]
+[ShortRunJob]
+public class PromiseBenchmarks
+{
+
+	// [GlobalSetup]
+	public void Setup()
+	{
+		var x = PromiseBase.Unit;
+	}
+	// [Benchmark]
+	public Promise<int> PromiseComplete()
+	{
+		var p = new Promise<int>();
+		//p.CompleteSuccess();
+		return p;
+	}
+	// [Benchmark]
+	public void PromiseAllocation_Many()
+	{
+		for (var i = 0; i < 10_000; i++)
+		{
+			var p = new Promise();
+		}
+	}
+
+	[Benchmark]
+	public async Task<int> Await()
+	{
+		var p = new Promise<int>();
+		p.CompleteSuccess(3);
+
+		return await p;
+	} 
+
+	// [Benchmark]
+	public Promise PromiseAllocation()
+	{
+		var p = new Promise();
+		return p;
+	} 
+
+
+	// [Benchmark]
+	public async Promise ReturnAsyncPromise()
+	{
+		// var p = new Promise();
+
+	}
+
+
+	// [Benchmark]
+	public async Promise AsyncAwait2()
+	{
+		var p = new Promise();
+		p.CompleteSuccess();
+	}
+
+	// [Benchmark]
+	public async Task Sequence()
+	{
+		var pList = Enumerable.Range(0, 10).Select(_ => new Promise<int>()).ToList();
+		var final = Promise.Sequence(pList);
+
+		var _ = pList.Select(p => Task.Run(async () =>
+		{
+			await Task.Delay(1);
+			p.CompleteSuccess(1);
+		})).ToList();
+
+		await final;
+	}
+
+	// [Benchmark]
+	public async Task WhenAll()
+	{
+		var pList = Enumerable.Range(0, 10).Select(_ => new Promise<int>()).ToList();
+		var final = Promise.WhenAll(pList);
+
+		var _ = pList.Select(p => Task.Run(async () =>
+		{
+			await Task.Delay(1);
+			p.CompleteSuccess(1);
+		})).ToList();
+
+		await final;
+	}
+}