Let caches clear and code commit in background

src/Nethermind/Nethermind.Consensus/Processing/BlockCachePreWarmer.cs

@@ -138,6 +138,10 @@ private void WarmupWithdrawals(ParallelOptions parallelOptions, IReleaseSpec spe
                     });
             }
         }
+        catch (ObjectDisposedException)
+        {
+            // Ignore, disposed object pool policy (cancelled in test DI)
+        }
         catch (OperationCanceledException)
         {
             // Ignore, block completed cancel

src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs

@@ -167,9 +167,6 @@ public Block[] Process(BlockHeader? baseBlock, IReadOnlyList<Block> suggestedBlo
                 }
 
                 preBlockBaseBlock = processedBlock.Header;
-                // Make sure the prewarm task is finished before we reset the state
-                preWarmTask?.GetAwaiter().GetResult();
-                preWarmTask = null;
                 _stateProvider.Reset();
 
                 // Calculate the transaction hashes in the background and release tx sequence memory
@@ -190,7 +187,6 @@ public Block[] Process(BlockHeader? baseBlock, IReadOnlyList<Block> suggestedBlo
             if (_logger.IsWarn) _logger.Warn($"Encountered exception {ex} while processing blocks.");
             CancellationTokenExtensions.CancelDisposeAndClear(ref prewarmCancellation);
             QueueClearCaches(preWarmTask);
-            preWarmTask?.GetAwaiter().GetResult();
             RestoreBranch(previousBranchStateRoot);
             throw;
         }

src/Nethermind/Nethermind.Core/Threading/ParallelUnbalancedWork.cs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Runtime.ExceptionServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,6 +21,7 @@ public class ParallelUnbalancedWork : IThreadPoolWorkItem
     };
 
     private readonly Data _data;
+    private ExceptionDispatchInfo? _exception;
 
     /// <summary>
     /// Executes a parallel for loop over a range of integers.
@@ -43,19 +45,28 @@ public static void For(int fromInclusive, int toExclusive, ParallelOptions paral
 
         Data data = new(threads, fromInclusive, toExclusive, action, parallelOptions.CancellationToken);
 
-        for (int i = 0; i < threads - 1; i++)
+        // Queue work items to the thread pool for all threads except the current one
+        var tasks = new ParallelUnbalancedWork[threads - 1];
+        for (int i = 0; i < tasks.Length; i++)
         {
-            ThreadPool.UnsafeQueueUserWorkItem(new ParallelUnbalancedWork(data), preferLocal: false);
+            ThreadPool.UnsafeQueueUserWorkItem((tasks[i] = new ParallelUnbalancedWork(data)), preferLocal: false);
         }
 
-        new ParallelUnbalancedWork(data).Execute();
+        var task = new ParallelUnbalancedWork(data);
+        task.Execute();
 
         // If there are still active threads, wait for them to complete
         if (data.ActiveThreads > 0)
         {
             data.Event.Wait();
         }
 
+        task._exception?.Throw();
+        for (int i = 0; i < tasks.Length; i++)
+        {
+            tasks[i]._exception?.Throw();
+        }
+
         parallelOptions.CancellationToken.ThrowIfCancellationRequested();
     }
 
@@ -150,6 +161,13 @@ public void Execute()
                 i = _data.Index.GetNext();
             }
         }
+        catch (Exception ex)
+        {
+            if (ex is not OperationCanceledException)
+            {
+                _exception = ExceptionDispatchInfo.Capture(ex);
+            }
+        }
         finally
         {
             // Signal that this thread has completed its work
@@ -237,6 +255,7 @@ private class Data(int threads, int fromInclusive, int toExclusive, Action<int>
     private class InitProcessor<TLocal> : IThreadPoolWorkItem
     {
         private readonly Data<TLocal> _data;
+        private ExceptionDispatchInfo? _exception;
 
         /// <summary>
         /// Executes a parallel for loop over a range of integers, with thread-local data initialization and finalization.
@@ -266,20 +285,28 @@ public static void For(
             var data = new Data<TLocal>(threads, fromInclusive, toExclusive, action, init, initValue, @finally, parallelOptions.CancellationToken);
 
             // Queue work items to the thread pool for all threads except the current one
-            for (int i = 0; i < threads - 1; i++)
+            var tasks = new InitProcessor<TLocal>[threads - 1];
+            for (int i = 0; i < tasks.Length; i++)
             {
-                ThreadPool.UnsafeQueueUserWorkItem(new InitProcessor<TLocal>(data), preferLocal: false);
+                ThreadPool.UnsafeQueueUserWorkItem((tasks[i] = new InitProcessor<TLocal>(data)), preferLocal: false);
             }
 
             // Execute work on the current thread
-            new InitProcessor<TLocal>(data).Execute();
+            var task = new InitProcessor<TLocal>(data);
+            task.Execute();
 
             // If there are still active threads, wait for them to complete
             if (data.ActiveThreads > 0)
             {
                 data.Event.Wait();
             }
 
+            task._exception?.Throw();
+            for (int i = 0; i < tasks.Length; i++)
+            {
+                tasks[i]._exception?.Throw();
+            }
+
             parallelOptions.CancellationToken.ThrowIfCancellationRequested();
         }
 
@@ -294,21 +321,31 @@ public static void For(
         /// </summary>
         public void Execute()
         {
-            TLocal? value = _data.Init();
             try
             {
-                int i = _data.Index.GetNext();
-                while (i < _data.ToExclusive)
+                TLocal? value = _data.Init();
+                try
                 {
-                    if (_data.CancellationToken.IsCancellationRequested) return;
-                    value = _data.Action(i, value);
-                    i = _data.Index.GetNext();
+                    int i = _data.Index.GetNext();
+                    while (i < _data.ToExclusive)
+                    {
+                        if (_data.CancellationToken.IsCancellationRequested) return;
+                        value = _data.Action(i, value);
+                        i = _data.Index.GetNext();
+                    }
+                }
+                finally
+                {
+                    _data.Finally(value);
+                    _data.MarkThreadCompleted();
                 }
             }
-            finally
+            catch (Exception ex)
             {
-                _data.Finally(value);
-                _data.MarkThreadCompleted();
+                if (ex is not OperationCanceledException)
+                {
+                    _exception = ExceptionDispatchInfo.Capture(ex);
+                }
             }
         }