Feat/revamp

src/NuGet.Config → NuGet.Config

@@ -2,5 +2,6 @@
 <configuration>
   <packageSources>
     <add key="Nuget" value="https://api.nuget.org/v3/index.json" />
+    <add key="UiPath-Internal" value="https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json" />
   </packageSources>
 </configuration>

benchmarks/Benchmarks.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.CoreIpc", "..\src\UiPath.CoreIpc\UiPath.CoreIpc.csproj", "{6E3048EE-987B-4846-84EF-305A286092B1}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UiPath.Ipc.Benchmarks", "UiPath.Ipc.Benchmarks\UiPath.Ipc.Benchmarks.csproj", "{D12CCF62-00C5-4291-A6A8-D3321C107EE7}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{6E3048EE-987B-4846-84EF-305A286092B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6E3048EE-987B-4846-84EF-305A286092B1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6E3048EE-987B-4846-84EF-305A286092B1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6E3048EE-987B-4846-84EF-305A286092B1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D12CCF62-00C5-4291-A6A8-D3321C107EE7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D12CCF62-00C5-4291-A6A8-D3321C107EE7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D12CCF62-00C5-4291-A6A8-D3321C107EE7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D12CCF62-00C5-4291-A6A8-D3321C107EE7}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

benchmarks/UiPath.Ipc.Benchmarks/IpcBenchmark.cs

@@ -0,0 +1,41 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using UiPath.Ipc.Benchmarks;
+
+[SimpleJob(RuntimeMoniker.Net461, baseline: true)]
+[SimpleJob(RuntimeMoniker.Net80)]
+[RPlotExporter]
+public class IpcBenchmark
+{
+    private Technology _technology = null!;
+    private Technology.IProxy _proxy = null!;
+
+    [Params(TechnologyId.Old, TechnologyId.New)]
+    public TechnologyId TechId;
+
+    [GlobalSetup]
+    public async Task Setup()
+    {
+        _technology = TechId.Create();
+        await _technology.Init();
+        _proxy = _technology.GetProxy();
+    }
+
+    [GlobalCleanup]
+    public async Task Cleanup()
+    {
+        await _technology.DisposeAsync();
+    }
+
+    [Benchmark]
+    public async Task SimpleCall()
+    {
+        _ = await _proxy.AddFloats(1, 1);
+    }
+
+    [Benchmark]
+    public async Task CallWithCallback()
+    {
+        _ = await _proxy.GetCallbackThreadName();
+    }
+}

benchmarks/UiPath.Ipc.Benchmarks/Program.cs

@@ -0,0 +1,15 @@
+using BenchmarkDotNet.Running;
+using UiPath.Ipc.Benchmarks;
+
+
+// await Run(TechnologyId.New);
+// BenchmarkRunner.Run<IpcBenchmark>();
+BenchmarkRunner.Run<SchedulerBenchmark>();
+
+static async Task Run(TechnologyId techId)
+{
+    await using var tech = techId.Create();
+    await tech.Init();
+    var x = await tech.GetProxy().AddFloats(1, 1);
+    Console.WriteLine($"{nameof(x)} == {x}");
+}

benchmarks/UiPath.Ipc.Benchmarks/SchedulerBenchmark.cs

@@ -0,0 +1,65 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using Nito.AsyncEx;
+
+[SimpleJob(RuntimeMoniker.Net461, baseline: true)]
+[SimpleJob(RuntimeMoniker.Net80)]
+[RPlotExporter]
+public class SchedulerBenchmark
+{
+    private TaskScheduler _scheduler = null!;
+
+    [Params(SchedulerKind.ConcurrentExclusive, SchedulerKind.AsyncContextThread)]
+    public SchedulerKind SchedulerKind;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _scheduler = SchedulerKind.Create();
+    }
+
+    [GlobalCleanup]
+    public void Cleanup()
+    {
+        _scheduler = null!;
+    }
+
+    [Benchmark]
+    public void Schedule()
+    {
+        _scheduler.RunAsync(async () =>
+        {
+        });
+    }
+}
+
+public enum SchedulerKind
+{
+    ConcurrentExclusive,
+    AsyncContextThread
+}
+
+public static class SchedulerKindExtensions
+{
+    public static TaskScheduler Create(this SchedulerKind schedulerKind)
+    {
+        switch (schedulerKind)
+        {
+            case SchedulerKind.ConcurrentExclusive:
+                return new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler;
+            case SchedulerKind.AsyncContextThread:
+                return new AsyncContextThread().Context.Scheduler;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(schedulerKind));
+        }
+    }
+}
+
+public static class TaskExtensions
+{
+    public static Task RunAsync(this TaskScheduler scheduler, Func<Task> asyncAction)
+    => Task.Factory.StartNew(asyncAction, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler).Unwrap();
+
+    public static Task<T> RunAsync<T>(this TaskScheduler scheduler, Func<Task<T>> asyncFunc)
+    => Task.Factory.StartNew(asyncFunc, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler).Unwrap();
+}

benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.New.cs

@@ -0,0 +1,106 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using UiPath.Ipc.Transport.NamedPipe;
+
+namespace UiPath.Ipc.Benchmarks;
+
+partial class Technology
+{
+    public sealed class New : Technology, IProxy
+    {
+        private const string PipeName = "BenchmarkPipeNew";
+        private const int ConcurrentAccepts = 10;
+        private const int MaxRequestMB = 100;
+
+        private static readonly TimeSpan ServerTimeout = TimeSpan.FromDays(1);
+        private static readonly TimeSpan ClientTimeout = TimeSpan.FromDays(1);
+        private readonly TaskScheduler _scheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler;
+
+        private readonly ComputingCallback _computingCallback = new();
+        private readonly ServiceProvider _serviceProvider;
+        private readonly IpcServer _server;
+        private readonly ClientBase _client;
+        private readonly IComputingService _proxy;
+
+        public New()
+        {
+            _serviceProvider = new ServiceCollection()
+                .AddLogging()
+                .AddSingleton<IComputingService, ComputingService>()
+                .BuildServiceProvider();
+
+            _server = new IpcServer
+            {
+                Endpoints = new()
+                {
+                    { typeof(IComputingService) }
+                },
+                Listeners = [
+                    new NamedPipeListener
+                    {
+                        PipeName = PipeName,
+                        RequestTimeout = ServerTimeout,
+                        ConcurrentAccepts = ConcurrentAccepts,
+                        MaxReceivedMessageSizeInMegabytes = MaxRequestMB
+                    }
+                ],
+                Scheduler = _scheduler,
+                ServiceProvider = _serviceProvider
+            };
+
+            _client = new NamedPipeClient
+            {
+                PipeName = PipeName,
+                AllowImpersonation = true,
+                RequestTimeout = TimeSpan.FromSeconds(5),
+                Scheduler = _scheduler,
+                Callbacks = new()
+                {
+                    { typeof(IComputingCallback), _computingCallback }
+                }
+            };
+
+            _proxy = _client.GetProxy<IComputingService>();
+        }
+
+        public override async Task Init()
+        {
+            _server.Start();
+            _ = await GetProxy().GetCallbackThreadName();
+        }
+
+        public override async ValueTask DisposeAsync()
+        {
+            (_proxy as IpcProxy)!.Dispose();
+            await _server.DisposeAsync();
+        }
+
+        public override IProxy GetProxy() => this;
+
+        Task<float> IProxy.AddFloats(float x, float y) => _proxy.AddFloats(x, y);
+        Task<string> IProxy.GetCallbackThreadName() => _proxy.GetCallbackThreadName(TimeSpan.Zero);
+
+
+        private interface IComputingService
+        {
+            Task<float> AddFloats(float x, float y, CancellationToken ct = default);
+            Task<string> GetCallbackThreadName(TimeSpan duration, Message message = null!, CancellationToken cancellationToken = default);
+        }
+
+        private sealed class ComputingService(ILogger<ComputingService> logger) : IComputingService
+        {
+            public async Task<float> AddFloats(float a, float b, CancellationToken ct = default)
+            {
+                logger.LogInformation($"{nameof(AddFloats)} called.");
+                return a + b;
+            }
+
+            public async Task<string> GetCallbackThreadName(TimeSpan duration, Message message = null!, CancellationToken cancellationToken = default)
+            {
+                await Task.Delay(duration);
+                return await message.GetCallback<IComputingCallback>().GetThreadName();
+            }
+        }
+    }
+}
+

benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.Old.cs

@@ -0,0 +1,99 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using UiPath.CoreIpc;
+using UiPath.CoreIpc.NamedPipe;
+
+namespace UiPath.Ipc.Benchmarks;
+
+partial class Technology
+{
+    public sealed class Old : Technology, IProxy
+    {
+        private const string PipeName = "BenchmarkPipeOld";
+        private const int ConcurrentAccepts = 10;
+        private const int MaxRequestMB = 100;
+
+        private static readonly TimeSpan ServerTimeout = TimeSpan.FromDays(1);
+        private static readonly TimeSpan ClientTimeout = TimeSpan.FromSeconds(1);
+        private readonly TaskScheduler _scheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler;
+        private Task? _serverRunning;
+
+        private readonly ComputingCallback _computingCallback = new();
+        private readonly ServiceProvider _serverServiceProvider;
+        private readonly ServiceProvider _clientServiceProvider;
+        private readonly ServiceHost _serviceHost;
+        private readonly IComputingService _proxy;
+
+        public Old()
+        {
+            _serverServiceProvider = new ServiceCollection()
+               .AddIpc()
+               .AddLogging()
+               .AddSingleton<IComputingService, ComputingService>()
+               .BuildServiceProvider();
+
+            _clientServiceProvider = new ServiceCollection()
+                .AddIpc()
+                .AddLogging()
+                .AddSingleton<IComputingCallback>(_computingCallback)
+                .BuildServiceProvider();
+
+            _serviceHost = new ServiceHostBuilder(_serverServiceProvider)
+                .AddEndpoint<IComputingService, IComputingCallback>()
+                .UseNamedPipes(new NamedPipeSettings(PipeName)
+                {
+                    RequestTimeout = ServerTimeout,
+                    ConcurrentAccepts = ConcurrentAccepts,
+                    MaxReceivedMessageSizeInMegabytes = MaxRequestMB,
+                })
+                .Build();
+
+            _proxy = new NamedPipeClientBuilder<IComputingService, IComputingCallback>(PipeName, _clientServiceProvider)
+                .AllowImpersonation()
+                .RequestTimeout(ClientTimeout)
+                .TaskScheduler(_scheduler)
+                .CallbackInstance(_computingCallback)
+                .Build();
+        }
+
+        public override async Task Init()
+        {
+            _serverRunning = _serviceHost.RunAsync(_scheduler);
+            _ = await GetProxy().GetCallbackThreadName();
+        }
+
+        public override async ValueTask DisposeAsync()
+        {
+            (_proxy as CoreIpc.IpcProxy)!.Dispose();
+            _serviceHost.Dispose();
+            await (_serverRunning ?? Task.CompletedTask);
+        }
+
+        public override IProxy GetProxy() => this;
+
+        Task<float> IProxy.AddFloats(float x, float y) => _proxy.AddFloats(x, y);
+        Task<string> IProxy.GetCallbackThreadName() => _proxy.GetCallbackThreadName(TimeSpan.Zero);
+
+        private interface IComputingService
+        {
+            Task<float> AddFloats(float x, float y, CancellationToken ct = default);
+            Task<string> GetCallbackThreadName(TimeSpan duration, CoreIpc.Message message = null!, CancellationToken cancellationToken = default);
+        }
+
+        private sealed class ComputingService(ILogger<ComputingService> logger) : IComputingService
+        {
+            public async Task<float> AddFloats(float a, float b, CancellationToken ct = default)
+            {
+                logger.LogInformation($"{nameof(AddFloats)} called.");
+                return a + b;
+            }
+
+            public async Task<string> GetCallbackThreadName(TimeSpan duration, CoreIpc.Message message = null!, CancellationToken cancellationToken = default)
+            {
+                await Task.Delay(duration);
+                return await message.GetCallback<IComputingCallback>().GetThreadName();
+            }
+        }
+    }
+}
+

benchmarks/UiPath.Ipc.Benchmarks/Switch/Technology.cs

@@ -0,0 +1,26 @@
+namespace UiPath.Ipc.Benchmarks;
+
+public abstract partial class Technology : IAsyncDisposable
+{
+    public abstract Task Init();
+    public abstract ValueTask DisposeAsync();
+
+    public abstract IProxy GetProxy();
+
+    public interface IProxy
+    {
+        Task<float> AddFloats(float x, float y);
+        Task<string> GetCallbackThreadName();
+    }
+
+    public interface IComputingCallback
+    {
+        Task<string> GetThreadName();
+    }
+
+    public sealed class ComputingCallback : IComputingCallback
+    {
+        public async Task<string> GetThreadName() => Thread.CurrentThread.Name!;
+    }
+}
+