Reduce allocations during checksum creation. (#76524)

* Reduce allocations during checksum creation.

From the csharp editing scrolling speedometer, I see about 0.3% of total allocations in the VS process occurring in Checksum.Create. A large part of these allocations are stream/writer constructions. Instead, this PR attempts to use a small pool to reuse and reset these objects.

Author: ToddGrun

src/Workspaces/Core/Portable/Workspace/Solution/Checksum_Factory.cs

@@ -23,6 +23,11 @@ internal readonly partial record struct Checksum
     private static readonly ObjectPool<XxHash128> s_incrementalHashPool =
         new(() => new(), size: 20);
 
+    // Pool of ObjectWriters to reduce allocations. The pool size is intentionally small as the writers are used for such
+    // a short period that concurrent usage of different items from the pool is infrequent.
+    private static readonly ObjectPool<ObjectWriter> s_objectWriterPool =
+        new(() => new(SerializableBytes.CreateWritableStream(), leaveOpen: true, writeValidationBytes: true), size: 4);
+
     public static Checksum Create(IEnumerable<string?> values)
     {
         using var pooledHash = s_incrementalHashPool.GetPooledObject();
@@ -57,15 +62,25 @@ public static Checksum Create(Stream stream)
 
     public static Checksum Create<T>(T @object, Action<T, ObjectWriter> writeObject)
     {
-        using var stream = SerializableBytes.CreateWritableStream();
+        // Obtain a writer from the pool
+        var objectWriter = s_objectWriterPool.Allocate();
 
-        using (var objectWriter = new ObjectWriter(stream, leaveOpen: true))
-        {
-            writeObject(@object, objectWriter);
-        }
+        // Invoke the callback to Write object into objectWriter
+        writeObject(@object, objectWriter);
 
+        // Include validation bytes in the new checksum from the stream
+        var stream = objectWriter.BaseStream;
         stream.Position = 0;
-        return Create(stream);
+        var newChecksum = Create(stream);
+
+        // Reset object writer back to it's initial state, including the validation bytes
+        objectWriter.Reset();
+        objectWriter.WriteValidationBytes();
+
+        // Release the writer back to the pool
+        s_objectWriterPool.Free(objectWriter);
+
+        return newChecksum;
     }
 
     public static Checksum Create(Checksum checksum1, Checksum checksum2)

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Serialization/ObjectWriter.WriterReferenceMap.cs

@@ -42,6 +42,12 @@ public readonly void Dispose()
             }
         }
 
+        public void Reset()
+        {
+            _valueToIdMap.Clear();
+            _nextId = 0;
+        }
+
         public bool TryGetReferenceId(string value, out int referenceId)
             => _valueToIdMap.TryGetValue(value, out referenceId);
 

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Serialization/ObjectWriter.cs

@@ -129,6 +129,28 @@ public void Dispose()
     public void WriteUInt16(ushort value) => _writer.Write(value);
     public void WriteString(string? value) => WriteStringValue(value);
 
+    public Stream BaseStream => _writer.BaseStream;
+
+    public void Reset()
+    {
+        _stringReferenceMap.Reset();
+
+        // Reset the position and length back to zero
+        _writer.BaseStream.Position = 0;
+
+        if (_writer.BaseStream is SerializableBytes.ReadWriteStream pooledStream)
+        {
+            // ReadWriteStream.SetLength allows us to indicate to not truncate, allowing
+            // reuse of the backing arrays.
+            pooledStream.SetLength(0, truncate: false);
+        }
+        else
+        {
+            // Otherwise, set the new length via the standard Stream.SetLength
+            _writer.BaseStream.SetLength(0);
+        }
+    }
+
     /// <summary>
     /// Used so we can easily grab the low/high 64bits of a guid for serialization.
     /// </summary>