Improvements to ConcurrentQueue Clear when it has a fixed-size.

Author: DennisCorvers

Lockless-Queue/ConcurrentQueue.cs

@@ -882,14 +882,19 @@ public void Clear()
             {
                 _tail.EnsureFrozenForEnqueues();
 
-                // Ensure the same capacity is retained when we are dealing with a fixedsize queue.
-                var segmentSize = InitialSegmentLength;
                 if (_fixedSize)
                 {
-                    segmentSize = _tail.Capacity;
-                }
+                    // No need to reallocate a QueueSegment when dealing with a fixed-size Queue.
+                    // The Head and Tail should always be the same in this case.
+                    System.Diagnostics.Debug.Assert(_tail == _head);
 
-                _tail = _head = new ConcurrentQueueSegment<T>(segmentSize);
+                    // Reset the sequence numbers of the Slots in our only QueueSegment.
+                    _head.Reset();
+                }
+                else
+                {
+                    _tail = _head = new ConcurrentQueueSegment<T>(InitialSegmentLength);
+                }
             }
         }
 

Lockless-Queue/ConcurrentQueueSegment.cs

@@ -9,6 +9,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Threading;
 
 namespace LocklessQueues
@@ -73,7 +74,7 @@ internal ConcurrentQueueSegment(int boundedLength)
         /// to a value that maps to the same slot but that won't be confused with
         /// any other enqueue/dequeue sequence number.
         /// </remarks>
-        internal void EnsureFrozenForEnqueues() 
+        internal void EnsureFrozenForEnqueues()
         {
             if (!_frozenForEnqueues)
             {
@@ -275,5 +276,19 @@ public bool TryEnqueue(T item)
                 spinner.SpinOnce();
             }
         }
+
+        /// <summary>
+        /// Resets the current <see cref="ConcurrentQueueSegment{T}"/>. Should only be used when the <see cref="ConcurrentQueue{T}"/> has a fixed size!
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void Reset()
+        {
+            _headAndTail = new HeadAndTail();
+            _preservedForObservation = default;
+            _frozenForEnqueues = default;
+
+            for (int i = 0; i < _slots.Length; i++)
+                _slots[i].SequenceNumber = i;
+        }
     }
 }

Lockless-Queue/Lockless-Queue.csproj

@@ -1,9 +1,23 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <RootNamespace>Lockless_Queue</RootNamespace>
     <LangVersion>7.1</LangVersion>
+    <Authors>Dennis Corvers</Authors>
+    <RepositoryUrl>https://github.com/DennisCorvers/Lockless-Queue</RepositoryUrl>
+    <NeutralLanguage />
+    <Description>A collection of lockless, concurrent queues.
+
+The following queue implementations are present:
+
+SPSC Queue (Single Producer, Single Consumer).
+MPSC Queue (Multi Producer, Single Consumer).
+Concurrent Queue (Multi Producer, Multi Consumer).
+The Concurrent Queue implementation is a copy of the .Net 5.0 implementation with the added option for a fixed-size queue. This queue is lockless if/when it is instantiated as a fixed-size queue.</Description>
+    <Copyright>Copyright (c) 2021 Dennis Corvers</Copyright>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <PackageLicenseUrl>https://github.com/DennisCorvers/Lockless-Queue/blob/master/LICENSE</PackageLicenseUrl>
   </PropertyGroup>
 
 </Project>