Speed up Maps.copyMapWithAddedEntry to Speed up ITs (#73308) (#74046)

This method is taking about 4% of CPU time with internal cluster tests
for me. 80% of that were coming from the slow immutability assertion,
the rest was due to the slow way we were building up the new map.
The CPU time slowness likely translates into outright test slowness,
because this was mainly hit through adding transport handlers when starting
nodes (which happens on the main test thread).

Fixed both to save a few % of test runtime.

Author: original-brownbear

server/src/main/java/org/elasticsearch/common/util/Maps.java

@@ -8,11 +8,11 @@
 
 package org.elasticsearch.common.util;
 
-import org.elasticsearch.Assertions;
-
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 public class Maps {
@@ -49,22 +49,31 @@ public static <K, V> boolean deepEquals(Map<K, V> left, Map<K, V> right) {
     public static <K, V> Map<K, V> copyMapWithRemovedEntry(final Map<K, V> map, final K key) {
         Objects.requireNonNull(map);
         Objects.requireNonNull(key);
-        assertImmutableMap(map, key, map.get(key));
+        assert checkIsImmutableMap(map, key, map.get(key));
         return map.entrySet().stream().filter(k -> key.equals(k.getKey()) == false)
             .collect(Collectors.collectingAndThen(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue),
                 Collections::<K, V>unmodifiableMap));
     }
 
-    private static <K, V> void assertImmutableMap(final Map<K, V> map, final K key, final V value) {
-        if (Assertions.ENABLED) {
-            boolean immutable;
-            try {
-                map.put(key, value);
-                immutable = false;
-            } catch (final UnsupportedOperationException e) {
-                immutable = true;
-            }
-            assert immutable : "expected an immutable map but was [" + map.getClass() + "]";
+    // map classes that are known to be immutable, used to speed up immutability check in #assertImmutableMap
+    private static final Set<Class<?>> IMMUTABLE_MAP_CLASSES = org.elasticsearch.core.Set.of(
+            Collections.emptyMap().getClass(),
+            Collections.unmodifiableMap(new HashMap<>()).getClass(),
+            org.elasticsearch.core.Map.of().getClass(),
+            org.elasticsearch.core.Map.of("a", "b").getClass()
+    );
+
+    private static <K, V> boolean checkIsImmutableMap(final Map<K, V> map, final K key, final V value) {
+        // check in the known immutable classes map first, most of the time we don't need to actually do the put and throw which is slow to
+        // the point of visibly slowing down internal cluster tests without this short-cut
+        if (IMMUTABLE_MAP_CLASSES.contains(map.getClass())) {
+            return true;
+        }
+        try {
+            map.put(key, value);
+            return false;
+        } catch (final UnsupportedOperationException ignored) {
         }
+        return true;
     }
 }