Dapr Actors (Next) SDK

.github/workflows/itests.yml

@@ -119,10 +119,24 @@ jobs:
           dotnet-version: '10.0.x'
           dotnet-quality: 'ga'
       - name: Restore dependencies
-        run: dotnet restore
+        run: |
+          dotnet restore ${{ github.workspace }}/test/Dapr.E2E.Test/Dapr.E2E.Test.csproj
+          dotnet restore ${{ github.workspace }}/test/Dapr.E2E.Test.Actors.Generators/Dapr.E2E.Test.Actors.Generators.csproj
       - name: Build
-        # disable deterministic builds, just for test run. Deterministic builds break coverage for some reason
-        run: dotnet build --configuration release --no-restore /p:GITHUB_ACTIONS=false
+        # Disable deterministic builds, just for test run. Deterministic builds break coverage for some reason.
+        # Build only the projects this workflow executes; the full solution includes example test projects
+        # that are covered by other CI jobs and should not participate in this integration-test workflow.
+        run: |
+          dotnet build ${{ github.workspace }}/test/Dapr.E2E.Test/Dapr.E2E.Test.csproj \
+            --configuration Release \
+            --framework ${{ matrix.framework }} \
+            --no-restore \
+            /p:GITHUB_ACTIONS=false
+          dotnet build ${{ github.workspace }}/test/Dapr.E2E.Test.Actors.Generators/Dapr.E2E.Test.Actors.Generators.csproj \
+            --configuration Release \
+            --framework ${{ matrix.framework }} \
+            --no-restore \
+            /p:GITHUB_ACTIONS=false
       - name: Run General Integration Tests
         id: tests
         continue-on-error: true # proceed if tests fail, the report step will report the failure with more details.

Directory.Build.props

@@ -0,0 +1,21 @@
+<Project>
+  <PropertyGroup>
+    <Nullable>enable</Nullable>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Deterministic>true</Deterministic>
+    <ContinuousIntegrationBuild Condition="'$(GITHUB_ACTIONS)' == 'true'">true</ContinuousIntegrationBuild>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(MSBuildProjectDirectory.Contains(`\src\`))' == 'true' Or '$(MSBuildProjectDirectory.EndsWith(`\src`))' == 'true'">
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(DaprActorsNextEnableTrimAotAnalysis)' == 'true'">
+    <IsAotCompatible>true</IsAotCompatible>
+    <IsTrimmable>true</IsTrimmable>
+    <EnableTrimAnalyzer>true</EnableTrimAnalyzer>
+    <EnableAotAnalyzer>true</EnableAotAnalyzer>
+    <EnableSingleFileAnalyzer>true</EnableSingleFileAnalyzer>
+  </PropertyGroup>
+</Project>

Directory.Packages.props

@@ -29,6 +29,7 @@
     <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="5.0.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing" Version="1.1.4" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing" Version="1.1.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit" Version="1.1.2" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.SourceGenerators.Testing" Version="1.1.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.SourceGenerators.Testing.XUnit" Version="1.1.2" />

benchmarks/Dapr.Actors.Benchmarks/ActorPackage.cs

@@ -0,0 +1,7 @@
+namespace Dapr.Actors.Benchmarks;
+
+public enum ActorPackage
+{
+    DaprActors,
+    DaprActorsNext,
+}

benchmarks/Dapr.Actors.Benchmarks/ActorsNextAotConfig.cs

@@ -0,0 +1,22 @@
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Toolchains.NativeAot;
+
+namespace Dapr.Actors.Benchmarks;
+
+public sealed class ActorsNextAotConfig : ManualConfig
+{
+    public ActorsNextAotConfig()
+    {
+        AddJob(Job.ShortRun
+            .WithRuntime(CoreRuntime.Core10_0)
+            .WithId(".NET 10 JIT")
+            .AsBaseline());
+
+        AddJob(Job.ShortRun
+            .WithRuntime(NativeAotRuntime.Net10_0)
+            .WithToolchain(NativeAotToolchain.Net10_0)
+            .WithId(".NET 10 Native AOT"));
+    }
+}

benchmarks/Dapr.Actors.Benchmarks/ActorsNextAotInvocationBenchmarks.cs

@@ -0,0 +1,53 @@
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Dapr.Actors.Benchmarks;
+
+[Config(typeof(ActorsNextAotConfig))]
+[MemoryDiagnoser]
+public class ActorsNextAotInvocationBenchmarks
+{
+    private const int ParallelCalls = 32;
+    private ServiceProvider provider = null!;
+    private int nextActorId;
+
+    [GlobalSetup]
+    public async Task Setup()
+    {
+        provider = BenchmarkHostFactory.CreateActorsNextServiceProvider(actorTypes: 1, useAotSerializer: true);
+        await BenchmarkHostFactory.InvokeAsync(provider, ActorPackage.DaprActorsNext, "warm").ConfigureAwait(false);
+    }
+
+    [GlobalCleanup]
+    public void Cleanup()
+    {
+        provider.Dispose();
+    }
+
+    [Benchmark]
+    public Task<int> WarmActorCall()
+    {
+        return BenchmarkHostFactory.InvokeAsync(provider, ActorPackage.DaprActorsNext, "warm");
+    }
+
+    [Benchmark]
+    public Task<int> ColdActorActivationCall()
+    {
+        var id = Interlocked.Increment(ref nextActorId).ToString();
+        return BenchmarkHostFactory.InvokeAsync(provider, ActorPackage.DaprActorsNext, id);
+    }
+
+    [Benchmark]
+    public async Task<int> ParallelFanOut()
+    {
+        var start = Interlocked.Add(ref nextActorId, ParallelCalls);
+        var tasks = new Task<int>[ParallelCalls];
+        for (var i = 0; i < tasks.Length; i++)
+        {
+            tasks[i] = BenchmarkHostFactory.InvokeAsync(provider, ActorPackage.DaprActorsNext, "aot-parallel-" + (start - i));
+        }
+
+        var results = await Task.WhenAll(tasks).ConfigureAwait(false);
+        return results.Sum();
+    }
+}

benchmarks/Dapr.Actors.Benchmarks/BenchmarkActors.cs

@@ -0,0 +1,104 @@
+using Dapr.Actors.Next.Abstractions.Attributes;
+using Dapr.Actors.Next.Abstractions.State;
+using Dapr.Actors.Next.Core.Activation;
+using LegacyActor = Dapr.Actors.Runtime.Actor;
+using LegacyActorHost = Dapr.Actors.Runtime.ActorHost;
+using LegacyIActor = Dapr.Actors.IActor;
+using NextActor = Dapr.Actors.Next.Abstractions.Actor;
+using NextActorId = Dapr.Actors.Next.Abstractions.ActorId;
+using NextIActor = Dapr.Actors.Next.Abstractions.IActor;
+
+namespace Dapr.Actors.Benchmarks;
+
+public interface ILegacyBenchmarkActor : LegacyIActor
+{
+    Task<int> AddAsync(int value);
+}
+
+public interface INextBenchmarkActor : NextIActor
+{
+    Task<int> AddAsync(int value, CancellationToken cancellationToken = default);
+}
+
+[GenerateActorClient]
+public interface INextBenchmarkActor01 : INextBenchmarkActor;
+
+[GenerateActorClient]
+public interface INextBenchmarkActor02 : INextBenchmarkActor;
+
+[GenerateActorClient]
+public interface INextBenchmarkActor03 : INextBenchmarkActor;
+
+[GenerateActorClient]
+public interface INextBenchmarkActor04 : INextBenchmarkActor;
+
+[GenerateActorClient]
+public interface INextBenchmarkActor05 : INextBenchmarkActor;
+
+[GenerateActorClient]
+public interface INextBenchmarkActor06 : INextBenchmarkActor;
+
+[GenerateActorClient]
+public interface INextBenchmarkActor07 : INextBenchmarkActor;
+
+[GenerateActorClient]
+public interface INextBenchmarkActor08 : INextBenchmarkActor;
+
+public abstract class LegacyBenchmarkActor(LegacyActorHost host) : LegacyActor(host), ILegacyBenchmarkActor
+{
+    private int value;
+
+    public Task<int> AddAsync(int value)
+    {
+        this.value += value;
+        return Task.FromResult(this.value);
+    }
+}
+
+public abstract class NextBenchmarkActor(ActorActivationContext context) : NextActor
+{
+    private int value;
+
+    protected override NextActorId Id => context.ActorId;
+
+    protected override IActorStateAccessor State => context.State;
+
+    public Task<int> AddAsync(int value, CancellationToken cancellationToken = default)
+    {
+        this.value += value;
+        return Task.FromResult(this.value);
+    }
+}
+
+public sealed class LegacyBenchmarkActor01(LegacyActorHost host) : LegacyBenchmarkActor(host);
+public sealed class LegacyBenchmarkActor02(LegacyActorHost host) : LegacyBenchmarkActor(host);
+public sealed class LegacyBenchmarkActor03(LegacyActorHost host) : LegacyBenchmarkActor(host);
+public sealed class LegacyBenchmarkActor04(LegacyActorHost host) : LegacyBenchmarkActor(host);
+public sealed class LegacyBenchmarkActor05(LegacyActorHost host) : LegacyBenchmarkActor(host);
+public sealed class LegacyBenchmarkActor06(LegacyActorHost host) : LegacyBenchmarkActor(host);
+public sealed class LegacyBenchmarkActor07(LegacyActorHost host) : LegacyBenchmarkActor(host);
+public sealed class LegacyBenchmarkActor08(LegacyActorHost host) : LegacyBenchmarkActor(host);
+
+[DaprActor("BenchmarkActor01")]
+public sealed class NextBenchmarkActor01(ActorActivationContext context) : NextBenchmarkActor(context), INextBenchmarkActor01;
+
+[DaprActor("BenchmarkActor02")]
+public sealed class NextBenchmarkActor02(ActorActivationContext context) : NextBenchmarkActor(context), INextBenchmarkActor02;
+
+[DaprActor("BenchmarkActor03")]
+public sealed class NextBenchmarkActor03(ActorActivationContext context) : NextBenchmarkActor(context), INextBenchmarkActor03;
+
+[DaprActor("BenchmarkActor04")]
+public sealed class NextBenchmarkActor04(ActorActivationContext context) : NextBenchmarkActor(context), INextBenchmarkActor04;
+
+[DaprActor("BenchmarkActor05")]
+public sealed class NextBenchmarkActor05(ActorActivationContext context) : NextBenchmarkActor(context), INextBenchmarkActor05;
+
+[DaprActor("BenchmarkActor06")]
+public sealed class NextBenchmarkActor06(ActorActivationContext context) : NextBenchmarkActor(context), INextBenchmarkActor06;
+
+[DaprActor("BenchmarkActor07")]
+public sealed class NextBenchmarkActor07(ActorActivationContext context) : NextBenchmarkActor(context), INextBenchmarkActor07;
+
+[DaprActor("BenchmarkActor08")]
+public sealed class NextBenchmarkActor08(ActorActivationContext context) : NextBenchmarkActor(context), INextBenchmarkActor08;

benchmarks/Dapr.Actors.Benchmarks/BenchmarkAotSerializers.cs

@@ -0,0 +1,46 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Dapr.Actors.Next.Core.Serialization;
+using Dapr.Common.Serialization;
+
+namespace Dapr.Actors.Benchmarks;
+
+public sealed class BenchmarkAotWireSerializer : IActorWireSerializer
+{
+    public byte[] JsonToBytes(string? json) =>
+        string.IsNullOrEmpty(json) ? [] : Encoding.UTF8.GetBytes(json);
+
+    public string? BytesToJson(ReadOnlyMemory<byte> bytes) =>
+        bytes.IsEmpty ? null : Encoding.UTF8.GetString(bytes.Span);
+
+    public byte[] SerializeToBytes<T>(T value) =>
+        JsonSerializer.SerializeToUtf8Bytes(value, typeof(T), BenchmarkAotJsonContext.Default);
+
+    public T? DeserializeFromBytes<T>(ReadOnlyMemory<byte> bytes) =>
+        bytes.IsEmpty ? default : (T?)JsonSerializer.Deserialize(bytes.Span, typeof(T), BenchmarkAotJsonContext.Default);
+}
+
+public sealed class BenchmarkAotDaprSerializer : IDaprSerializer
+{
+    public string Serialize<T>(T value) =>
+        JsonSerializer.Serialize(value, typeof(T), BenchmarkAotJsonContext.Default);
+
+    [RequiresUnreferencedCode("Runtime-type serialization is not used by this AOT benchmark.")]
+    [RequiresDynamicCode("Runtime-type serialization is not used by this AOT benchmark.")]
+    public string Serialize(object? value, Type? inputType = null) =>
+        JsonSerializer.Serialize(value, inputType ?? value?.GetType() ?? typeof(object), BenchmarkAotJsonContext.Default);
+
+    public T? Deserialize<T>(string? data) =>
+        string.IsNullOrEmpty(data) ? default : (T?)JsonSerializer.Deserialize(data, typeof(T), BenchmarkAotJsonContext.Default);
+
+    [RequiresUnreferencedCode("Runtime-type deserialization is not used by this AOT benchmark.")]
+    [RequiresDynamicCode("Runtime-type deserialization is not used by this AOT benchmark.")]
+    public object? Deserialize(string? data, Type returnType) =>
+        string.IsNullOrEmpty(data) ? null : JsonSerializer.Deserialize(data, returnType, BenchmarkAotJsonContext.Default);
+}
+
+[JsonSerializable(typeof(int))]
+[JsonSerializable(typeof(object))]
+internal sealed partial class BenchmarkAotJsonContext : JsonSerializerContext;