fix: 17219: WARN EXCEPTION "virtual-map: cache-cleaner StandardFuture: Future has already been cancelled"

platform-sdk/swirlds-virtualmap/src/main/java/com/swirlds/virtualmap/internal/cache/ConcurrentArray.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2024 Hedera Hashgraph, LLC
+ * Copyright (C) 2021-2025 Hedera Hashgraph, LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,8 @@
 
 package com.swirlds.virtualmap.internal.cache;
 
+import static com.swirlds.logging.legacy.LogMarker.EXCEPTION;
+
 import com.swirlds.common.threading.futures.StandardFuture;
 import java.util.NoSuchElementException;
 import java.util.Objects;
@@ -27,6 +29,8 @@
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 /**
  * An array-backed concurrent data structure optimized for use by the {@link VirtualNodeCache}.
@@ -58,6 +62,9 @@
  * 		the element type
  */
 final class ConcurrentArray<T> {
+
+    private static final Logger logger = LogManager.getLogger(ConcurrentArray.class);
+
     /**
      * The default number of elements to store in each array
      */
@@ -338,6 +345,7 @@
         }
 
         final StandardFuture<Void> result = new StandardFuture<>();
+        final AtomicBoolean exceptionThrown = new AtomicBoolean(false);
         final AtomicInteger count = new AtomicInteger(1);
         int nextIndex = 0;
         int numberOfElements = elementCount.get();
@@ -354,7 +362,11 @@
                         result.complete(null);
                     }
                 } catch (Exception e) {
-                    result.cancelWithError(e);
+                    logger.error(EXCEPTION.getMarker(), "Exception in parallelTraverse", e);
+                    // Don't cancel the result future more than once
+                    if (exceptionThrown.compareAndSet(false, true)) {
+                        result.cancelWithError(e);
+                    }
                 }
             });
             nextIndex += size;

platform-sdk/swirlds-virtualmap/src/main/java/com/swirlds/virtualmap/internal/cache/VirtualNodeCache.java

@@ -18,6 +18,7 @@
 
 import static com.swirlds.common.threading.manager.AdHocThreadManager.getStaticThreadManager;
 import static com.swirlds.logging.legacy.LogMarker.EXCEPTION;
+import static com.swirlds.logging.legacy.LogMarker.VIRTUAL_MERKLE_STATS;
 import static com.swirlds.virtualmap.internal.cache.VirtualNodeCache.CLASS_ID;
 import static java.util.Objects.requireNonNull;
 
@@ -493,18 +494,16 @@ public boolean release() {
 
         // Fire off the cleaning threads to go and clear out data in the indexes that doesn't need
         // to be there anymore.
-        getCleaningPool(virtualMapConfig).execute(() -> {
-            purge(dirtyLeaves, keyToDirtyLeafIndex, virtualMapConfig);
-            purge(dirtyLeafPaths, pathToDirtyLeafIndex, virtualMapConfig);
-            purge(dirtyHashes, pathToDirtyHashIndex, virtualMapConfig);
-
-            dirtyLeaves = null;
-            dirtyLeafPaths = null;
-            dirtyHashes = null;
-        });
+        purge(dirtyLeaves, keyToDirtyLeafIndex, virtualMapConfig);
+        purge(dirtyLeafPaths, pathToDirtyLeafIndex, virtualMapConfig);
+        purge(dirtyHashes, pathToDirtyHashIndex, virtualMapConfig);
+
+        dirtyLeaves = null;
+        dirtyLeafPaths = null;
+        dirtyHashes = null;
 
         if (logger.isTraceEnabled()) {
-            logger.trace("Released {}", fastCopyVersion);
+            logger.trace(VIRTUAL_MERKLE_STATS.getMarker(), "Released {}", fastCopyVersion);
         }
 
         return true;
@@ -553,6 +552,7 @@ public void merge() {
 
             if (logger.isTraceEnabled()) {
                 logger.trace(
+                        VIRTUAL_MERKLE_STATS.getMarker(),
                         "Merged version {}, {} dirty leaves, {} dirty internals",
                         fastCopyVersion,
                         dirtyLeaves.size(),
@@ -1434,11 +1434,11 @@ private Mutation<K, VirtualLeafRecord<K, V>> mutate(
      * @param <V>
      * 		The value type referenced by the mutation list
      */
-    private static <K, V> void purge(
+    private static <K, V> StandardFuture<Void> purge(
             final ConcurrentArray<Mutation<K, V>> array,
             final Map<K, Mutation<K, V>> index,
             @NonNull final VirtualMapConfig virtualMapConfig) {
-        array.parallelTraverse(getCleaningPool(virtualMapConfig), element -> {
+        return array.parallelTraverse(getCleaningPool(virtualMapConfig), element -> {
             if (element.isFiltered()) {
                 return;
             }