Release 5.25.2

sakno · sakno · commit f63be53fb140 · 2025-09-29T10:37:19.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,16 @@
 Release Notes
 ====
 
+# 09-29-2025
+<a href="https://www.nuget.org/packages/dotnext.threading/5.25.2">DotNext.Threading 5.25.2</a>
+* Fixed [272](https://github.com/dotnet/dotNext/pull/272)
+
+<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.25.2">DotNext.Net.Cluster 5.25.2</a>
+* Forced upgrade to newer `DotNext.Threading` library
+
+<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.25.2">DotNext.AspNetCore.Cluster 5.25.2</a>
+* Forced upgrade to newer `DotNext.Threading` library
+
 # 09-15-2025
 <a href="https://www.nuget.org/packages/dotnext/5.25.0">DotNext 5.25.0</a>
 * Added `CatchException` extension method to capture the exception produced by `await` operator instead of raising it at the call site
diff --git a/README.md b/README.md
@@ -44,36 +44,16 @@ All these things are implemented in 100% managed code on top of existing .NET AP
 * [NuGet Packages](https://www.nuget.org/profiles/rvsakno)
 
 # What's new
-Release Date: 09-15-2025
+Release Date: 09-29-2025
 
-<a href="https://www.nuget.org/packages/dotnext/5.25.0">DotNext 5.25.0</a>
-* Added `CatchException` extension method to capture the exception produced by `await` operator instead of raising it at the call site
-* Various performance improvements
+<a href="https://www.nuget.org/packages/dotnext.threading/5.25.2">DotNext.Threading 5.25.2</a>
+* Fixed [272](https://github.com/dotnet/dotNext/pull/272)
 
-<a href="https://www.nuget.org/packages/dotnext.metaprogramming/5.25.0">DotNext.Metaprogramming 5.25.0</a>
-* Fixed mutability modifiers for properties of `UnmanagedMemory<T>` type
+<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.25.2">DotNext.Net.Cluster 5.25.2</a>
+* Forced upgrade to newer `DotNext.Threading` library
 
-<a href="https://www.nuget.org/packages/dotnext.unsafe/5.25.0">DotNext.Unsafe 5.25.0</a>
-* Updated dependencies
-
-<a href="https://www.nuget.org/packages/dotnext.threading/5.25.0">DotNext.Threading 5.25.0</a>
-* Added optional hard concurrency limit for async lock primitives
-* Rewritten the internal engine for async lock primitives to decrease the lock contention and increase the response time
-* Async lock primitive no longer produce lock contention time to improve the response time
-
-<a href="https://www.nuget.org/packages/dotnext.io/5.25.0">DotNext.IO 5.25.0</a>
-* Updated dependencies
-
-<a href="https://www.nuget.org/packages/dotnext.net.cluster/5.25.0">DotNext.Net.Cluster 5.25.0</a>
-* Updated dependencies
-
-<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.25.0">DotNext.AspNetCore.Cluster 5.25.0</a>
-* Updated dependencies
-
-<a href="https://www.nuget.org/packages/dotnext.maintenanceservices/0.6.0">DotNext.MaintenanceServices 0.6.0</a>
-* Upgrade to newer `System.CommandLine` library
-* Interactive session now prints `>` in the prompt
-* Fixed buffer leak caused by interactive session
+<a href="https://www.nuget.org/packages/dotnext.aspnetcore.cluster/5.25.2">DotNext.AspNetCore.Cluster 5.25.2</a>
+* Forced upgrade to newer `DotNext.Threading` library
 
 Changelog for previous versions located [here](./CHANGELOG.md).
 
diff --git a/src/DotNext.Tests/Threading/CancellationTokenMultiplexerTests.cs b/src/DotNext.Tests/Threading/CancellationTokenMultiplexerTests.cs
@@ -40,6 +40,23 @@ public static void CheckPooling()
         }
     }
 
+    [Fact]
+    public async Task CheckPoolingNonInterference()
+    {
+        var multiplexer = new CancellationTokenMultiplexer();
+
+        using var cts = new CancellationTokenSource();
+
+        await multiplexer.Combine([cts.Token, cts.Token, cts.Token]).DisposeAsync();
+
+        // same source is reused from pool, but should now not be associated with cts.
+        await using var combined = multiplexer.Combine([new(), new(), new()]);
+
+        cts.Cancel();
+
+        False(combined.Token.IsCancellationRequested);
+    }
+
     [Fact]
     public static void ExtraListOverflow()
     {
diff --git a/src/DotNext.Threading/DotNext.Threading.csproj b/src/DotNext.Threading/DotNext.Threading.csproj
@@ -7,7 +7,7 @@
     <ImplicitUsings>true</ImplicitUsings>
     <IsAotCompatible>true</IsAotCompatible>
     <Features>nullablePublicOnly</Features>
-    <VersionPrefix>5.25.1</VersionPrefix>
+    <VersionPrefix>5.25.2</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <Authors>.NET Foundation and Contributors</Authors>
     <Product>.NEXT Family of Libraries</Product>
diff --git a/src/DotNext.Threading/Threading/CancellationTokenMultiplexer.CTS.cs b/src/DotNext.Threading/Threading/CancellationTokenMultiplexer.CTS.cs
@@ -1,6 +1,5 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 
 namespace DotNext.Threading;
 
@@ -13,46 +12,54 @@ private sealed class PooledCancellationTokenSource : LinkedCancellationTokenSour
         private static readonly int InlinedListCapacity = GetCapacity<InlinedTokenList>();
         
         private InlinedTokenList inlinedList;
-        private int inlinedTokenCount;
-        private List<CancellationTokenRegistration>? extraTokens;
+        private int count;
+        private CancellationTokenRegistration[]? extraTokens;
         internal PooledCancellationTokenSource? Next;
 
-        public void Add(CancellationToken token)
-            => Add(Attach(token));
-
-        private void Add(CancellationTokenRegistration registration)
+        public void AddRange(ReadOnlySpan<CancellationToken> tokens)
         {
-            if (inlinedTokenCount < InlinedListCapacity)
+            // register inlined tokens
+            var inlinedRegistrations = inlinedList.AsSpan();
+            var inlinedCount = Math.Min(inlinedRegistrations.Length, tokens.Length);
+
+            for (var i = 0; i < inlinedCount; i++)
             {
-                Unsafe.Add(ref FirstInlinedRegistration, inlinedTokenCount++) = registration;
+                inlinedRegistrations[i] = Attach(tokens[i]);
             }
-            else
+
+            // register extra tokens
+            tokens = tokens.Slice(inlinedCount);
+            count = inlinedCount + tokens.Length;
+            if (tokens.IsEmpty)
+                return;
+
+            if (extraTokens is null || extraTokens.Length < tokens.Length)
             {
-                extraTokens ??= new();
-                extraTokens.Add(registration);
+                extraTokens = new CancellationTokenRegistration[tokens.Length];
             }
-        }
 
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private ref CancellationTokenRegistration FirstInlinedRegistration
-            => ref Unsafe.As<InlinedTokenList, CancellationTokenRegistration>(ref inlinedList);
+            for (var i = 0; i < tokens.Length; i++)
+            {
+                extraTokens[i] = Attach(tokens[i]);
+            }
+        }
 
-        public int Count => inlinedTokenCount + extraTokens?.Count ?? 0;
+        public int Count => count;
 
-        public ref CancellationTokenRegistration this[int index]
+        public ref readonly CancellationTokenRegistration this[int index]
         {
             get
             {
-                Debug.Assert((uint)index < (uint)Count);
-                
+                Debug.Assert((uint)index < (uint)count);
+
                 Span<CancellationTokenRegistration> registrations;
                 if (index < InlinedListCapacity)
                 {
                     registrations = inlinedList.AsSpan();
                 }
                 else
                 {
-                    registrations = CollectionsMarshal.AsSpan(extraTokens);
+                    registrations = extraTokens;
                     index -= InlinedListCapacity;
                 }
 
@@ -62,9 +69,14 @@ public ref CancellationTokenRegistration this[int index]
 
         public void Reset()
         {
-            inlinedTokenCount = 0;
             inlinedList = default;
-            extraTokens?.Clear();
+
+            if (extraTokens is not null && count > InlinedListCapacity)
+            {
+                Array.Clear(extraTokens, 0, count - InlinedListCapacity);
+            }
+
+            count = 0;
         }
 
         private static int GetCapacity<T>()
diff --git a/src/DotNext.Threading/Threading/CancellationTokenMultiplexer.Scope.cs b/src/DotNext.Threading/Threading/CancellationTokenMultiplexer.Scope.cs
@@ -22,39 +22,13 @@ partial class CancellationTokenMultiplexer
 
         internal Scope(CancellationTokenMultiplexer multiplexer, ReadOnlySpan<CancellationToken> tokens)
         {
-            switch (tokens)
-            {
-                case []:
-                    source = null;
-                    multiplexerOrToken = InlineToken(new(canceled: false));
-                    break;
-                case [var token]:
-                    source = null;
-                    multiplexerOrToken = InlineToken(token);
-                    break;
-                case [var token1, var token2]:
-                    source = null;
-                    if (!token1.CanBeCanceled || token1 == token2)
-                    {
-                        multiplexerOrToken = InlineToken(token2);
-                    }
-                    else if (!token2.CanBeCanceled)
-                    {
-                        multiplexerOrToken = InlineToken(token1);
-                    }
-                    else
-                    {
-                        goto default;
-                    }
-
-                    break;
-                default:
-                    multiplexerOrToken = new(multiplexer);
-                    source = multiplexer.Rent(tokens);
-                    break;
-            }
+            multiplexerOrToken = new(multiplexer);
+            source = multiplexer.Rent(tokens);
         }
 
+        internal Scope(CancellationToken token)
+            => multiplexerOrToken = InlineToken(token);
+
         private static ValueTuple<object> InlineToken(CancellationToken token)
             => CanInlineToken ? Unsafe.BitCast<CancellationToken, ValueTuple<object>>(token) : new(token);
 
diff --git a/src/DotNext.Threading/Threading/CancellationTokenMultiplexer.cs b/src/DotNext.Threading/Threading/CancellationTokenMultiplexer.cs
@@ -30,7 +30,38 @@ public int MaximumRetained
     /// <param name="tokens">The tokens to be combined.</param>
     /// <returns>The scope that contains a single multiplexed token.</returns>
     public Scope Combine(ReadOnlySpan<CancellationToken> tokens) // TODO: use params
-        => new(this, tokens);
+    {
+        Scope scope;
+        switch (tokens)
+        {
+            case []:
+                scope = new();
+                break;
+            case [var token]:
+                scope = new(token);
+                break;
+            case [var token1, var token2]:
+                if (!token1.CanBeCanceled || token1 == token2)
+                {
+                    scope = new(token2);
+                }
+                else if (!token2.CanBeCanceled)
+                {
+                    scope = new(token1);
+                }
+                else
+                {
+                    goto default;
+                }
+
+                break;
+            default:
+                scope = new(this, tokens);
+                break;
+        }
+
+        return scope;
+    }
 
     private void Return(PooledCancellationTokenSource source)
     {
@@ -87,11 +118,9 @@ private PooledCancellationTokenSource Rent(ReadOnlySpan<CancellationToken> token
         var source = Rent();
         Debug.Assert(source.Count is 0);
 
-        foreach (var token in tokens)
-        {
-            source.Add(token);
-        }
-
+        source.AddRange(tokens);
+        Debug.Assert(source.Count == tokens.Length);
+        
         return source;
     }
 }
diff --git a/src/cluster/DotNext.AspNetCore.Cluster/DotNext.AspNetCore.Cluster.csproj b/src/cluster/DotNext.AspNetCore.Cluster/DotNext.AspNetCore.Cluster.csproj
@@ -8,7 +8,7 @@
     <ImplicitUsings>true</ImplicitUsings>
     <IsAotCompatible>true</IsAotCompatible>
     <Features>nullablePublicOnly</Features>
-    <VersionPrefix>5.25.0</VersionPrefix>
+    <VersionPrefix>5.25.2</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <Authors>.NET Foundation and Contributors</Authors>
     <Product>.NEXT Family of Libraries</Product>
diff --git a/src/cluster/DotNext.Net.Cluster/DotNext.Net.Cluster.csproj b/src/cluster/DotNext.Net.Cluster/DotNext.Net.Cluster.csproj
@@ -8,7 +8,7 @@
     <Nullable>enable</Nullable>
     <IsAotCompatible>true</IsAotCompatible>
     <Features>nullablePublicOnly</Features>
-    <VersionPrefix>5.25.0</VersionPrefix>
+    <VersionPrefix>5.25.2</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <Authors>.NET Foundation and Contributors</Authors>
     <Product>.NEXT Family of Libraries</Product>
