experiment

Author: michaelstaib

src/HotChocolate/Fusion/src/Fusion.Execution/Execution/Results/FetchResultStore.cs

@@ -1,19 +1,16 @@
 using System.Buffers;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text.Json;
 using HotChocolate.Buffers;
 using HotChocolate.Execution;
 using HotChocolate.Fusion.Execution.Clients;
 using HotChocolate.Fusion.Execution.Nodes;
-using HotChocolate.Fusion.Language;
 using HotChocolate.Fusion.Text.Json;
 using HotChocolate.Language;
 using HotChocolate.Types;
-using HotChocolate.Text.Json;
 
 namespace HotChocolate.Fusion.Execution.Results;
 
@@ -114,38 +111,46 @@ public bool AddPartialResults(
                 errorTriesSpan[i] = GetErrorTrie(sourcePath, errors?.Trie);
             }
 
+            // Admin-only: bookkeeping mutations under narrow lock, not SaveSafeResult.
             lock (_lock)
             {
-                try
+                if (rootErrors is not null)
                 {
-                    if (rootErrors is not null)
-                    {
-                        _errors ??= [];
-                        _errors.AddRange(rootErrors);
-                    }
+                    _errors ??= [];
+                    _errors.AddRange(rootErrors);
+                }
+
+                for (var i = 0; i < results.Length; i++)
+                {
+                    _memory.Add(results[i]);
+                }
+            }
 
-                    var resultData = _result.Data;
+            try
+            {
+                var resultData = _result.Data;
 
-                    for (var i = 0; i < results.Length; i++)
+                for (var i = 0; i < results.Length; i++)
+                {
+                    var result = results[i];
+
+                    if (!SaveSafeResult(
+                            resultData,
+                            result.Path,
+                            result.AdditionalPaths.AsSpan(),
+                            dataElementsSpan[i],
+                            errorTriesSpan[i],
+                            resultSelectionSet))
                     {
-                        var result = results[i];
-                        _memory.Add(result);
-
-                        if (!SaveSafeResult(
-                                resultData,
-                                result.Path,
-                                result.AdditionalPaths.AsSpan(),
-                                dataElementsSpan[i],
-                                errorTriesSpan[i],
-                                resultSelectionSet))
-                        {
-                            return false;
-                        }
+                        return false;
                     }
-
-                    return true;
                 }
-                finally
+
+                return true;
+            }
+            finally
+            {
+                lock (_lock)
                 {
                     ReturnPathSegments(results);
                 }
@@ -177,30 +182,37 @@ private bool AddPartialResultsNoErrors(
 
             lock (_lock)
             {
-                try
+                for (var i = 0; i < results.Length; i++)
                 {
-                    var resultData = _result.Data;
+                    _memory.Add(results[i]);
+                }
+            }
+
+            try
+            {
+                var resultData = _result.Data;
 
-                    for (var i = 0; i < results.Length; i++)
+                for (var i = 0; i < results.Length; i++)
+                {
+                    var result = results[i];
+
+                    if (!SaveSafeResult(
+                            resultData,
+                            result.Path,
+                            result.AdditionalPaths.AsSpan(),
+                            dataElementsSpan[i],
+                            errorTrie: null,
+                            resultSelectionSet))
                     {
-                        var result = results[i];
-                        _memory.Add(result);
-
-                        if (!SaveSafeResult(
-                                resultData,
-                                result.Path,
-                                result.AdditionalPaths.AsSpan(),
-                                dataElementsSpan[i],
-                                errorTrie: null,
-                                resultSelectionSet))
-                        {
-                            return false;
-                        }
+                        return false;
                     }
-
-                    return true;
                 }
-                finally
+
+                return true;
+            }
+            finally
+            {
+                lock (_lock)
                 {
                     ReturnPathSegments(results);
                 }
@@ -226,23 +238,26 @@ private bool AddSinglePartialResult(
         {
             _memory.Add(result);
 
-            try
+            if (errors?.RootErrors is { Length: > 0 } rootErrors)
             {
-                if (errors?.RootErrors is { Length: > 0 } rootErrors)
-                {
-                    _errors ??= [];
-                    _errors.AddRange(rootErrors);
-                }
-
-                return SaveSafeResult(
-                    _result.Data,
-                    result.Path,
-                    result.AdditionalPaths.AsSpan(),
-                    dataElement,
-                    errorTrie,
-                    resultSelectionSet);
+                _errors ??= [];
+                _errors.AddRange(rootErrors);
             }
-            finally
+        }
+
+        try
+        {
+            return SaveSafeResult(
+                _result.Data,
+                result.Path,
+                result.AdditionalPaths.AsSpan(),
+                dataElement,
+                errorTrie,
+                resultSelectionSet);
+        }
+        finally
+        {
+            lock (_lock)
             {
                 ReturnPathSegments(result);
             }
@@ -259,18 +274,21 @@ private bool AddSinglePartialResultNoErrors(
         lock (_lock)
         {
             _memory.Add(result);
+        }
 
-            try
-            {
-                return SaveSafeResult(
-                    _result.Data,
-                    result.Path,
-                    result.AdditionalPaths.AsSpan(),
-                    dataElement,
-                    errorTrie: null,
-                    resultSelectionSet);
-            }
-            finally
+        try
+        {
+            return SaveSafeResult(
+                _result.Data,
+                result.Path,
+                result.AdditionalPaths.AsSpan(),
+                dataElement,
+                errorTrie: null,
+                resultSelectionSet);
+        }
+        finally
+        {
+            lock (_lock)
             {
                 ReturnPathSegments(result);
             }

src/HotChocolate/Fusion/src/Fusion.Execution/Text/Json/CompositeResultDocument.cs

@@ -14,6 +14,13 @@ public sealed partial class CompositeResultDocument : IDisposable
     private readonly Operation _operation;
     private readonly ulong _includeFlags;
     private readonly PathSegmentLocalPool? _pathPool;
+#if NET9_0_OR_GREATER
+    private readonly Lock _metaDbLock = new();
+    private readonly Lock _sourcesLock = new();
+#else
+    private readonly object _metaDbLock = new();
+    private readonly object _sourcesLock = new();
+#endif
     internal MetaDb _metaDb;
     private bool _disposed;
 
@@ -341,32 +348,38 @@ private ReadOnlySpan<byte> ReadRawValue(DbRow row)
 
     internal CompositeResultElement CreateObject(Cursor parent, SelectionSet selectionSet)
     {
-        var startObjectCursor = WriteStartObject(parent, selectionSet.Id);
-
-        var selectionCount = 0;
-        foreach (var selection in selectionSet.Selections)
+        lock (_metaDbLock)
         {
-            WriteEmptyProperty(startObjectCursor, selection);
-            selectionCount++;
-        }
+            var startObjectCursor = WriteStartObject(parent, selectionSet.Id);
+
+            var selectionCount = 0;
+            foreach (var selection in selectionSet.Selections)
+            {
+                WriteEmptyProperty(startObjectCursor, selection);
+                selectionCount++;
+            }
 
-        WriteEndObject(startObjectCursor, selectionCount);
+            WriteEndObject(startObjectCursor, selectionCount);
 
-        return new CompositeResultElement(this, startObjectCursor);
+            return new CompositeResultElement(this, startObjectCursor);
+        }
     }
 
     internal CompositeResultElement CreateArray(Cursor parent, int length)
     {
-        var cursor = WriteStartArray(parent, length);
-
-        for (var i = 0; i < length; i++)
+        lock (_metaDbLock)
         {
-            WriteEmptyValue(cursor);
-        }
+            var cursor = WriteStartArray(parent, length);
 
-        WriteEndArray();
+            for (var i = 0; i < length; i++)
+            {
+                WriteEmptyValue(cursor);
+            }
 
-        return new CompositeResultElement(this, cursor);
+            WriteEndArray();
+
+            return new CompositeResultElement(this, cursor);
+        }
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -387,9 +400,15 @@ internal void AssignSourceValue(CompositeResultElement target, SourceResultEleme
 
         if (parent.Id == -1)
         {
-            Debug.Assert(!_sources.Contains(parent), "The source document is marked as unbound but is already registered.");
-            parent.Id = _sources.Count;
-            _sources.Add(parent);
+            lock (_sourcesLock)
+            {
+                if (parent.Id == -1)
+                {
+                    Debug.Assert(!_sources.Contains(parent), "The source document is marked as unbound but is already registered.");
+                    parent.Id = _sources.Count;
+                    _sources.Add(parent);
+                }
+            }
         }
 
         Debug.Assert(_sources.Contains(parent), "Expected the source document of the source element to be registered.");