Use cheaper map for RoutingNode.shardsByIndex (#87599)

No need for preserving order on this map, it's only used for counting
shards of a specific index per node.

Author: original-brownbear

server/src/main/java/org/elasticsearch/cluster/routing/RoutingNode.java

@@ -17,6 +17,8 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
@@ -44,15 +46,15 @@ public class RoutingNode implements Iterable<ShardRouting> {
 
     private final LinkedHashSet<ShardRouting> relocatingShards;
 
-    private final Map<Index, LinkedHashSet<ShardRouting>> shardsByIndex;
+    private final Map<Index, Set<ShardRouting>> shardsByIndex;
 
     RoutingNode(String nodeId, @Nullable DiscoveryNode node) {
         this.nodeId = nodeId;
         this.node = node;
         this.shards = new LinkedHashMap<>();
         this.relocatingShards = new LinkedHashSet<>();
         this.initializingShards = new LinkedHashSet<>();
-        this.shardsByIndex = new LinkedHashMap<>();
+        this.shardsByIndex = new HashMap<>();
         assert invariant();
     }
 
@@ -62,9 +64,9 @@ private RoutingNode(RoutingNode original) {
         this.shards = new LinkedHashMap<>(original.shards);
         this.relocatingShards = new LinkedHashSet<>(original.relocatingShards);
         this.initializingShards = new LinkedHashSet<>(original.initializingShards);
-        this.shardsByIndex = Maps.newLinkedHashMapWithExpectedSize(original.shardsByIndex.size());
-        for (Map.Entry<Index, LinkedHashSet<ShardRouting>> entry : original.shardsByIndex.entrySet()) {
-            shardsByIndex.put(entry.getKey(), new LinkedHashSet<>(entry.getValue()));
+        this.shardsByIndex = Maps.newMapWithExpectedSize(original.shardsByIndex.size());
+        for (Map.Entry<Index, Set<ShardRouting>> entry : original.shardsByIndex.entrySet()) {
+            shardsByIndex.put(entry.getKey(), new HashSet<>(entry.getValue()));
         }
         assert invariant();
     }
@@ -133,7 +135,7 @@ void add(ShardRouting shard) {
         } else if (shard.relocating()) {
             relocatingShards.add(shard);
         }
-        shardsByIndex.computeIfAbsent(shard.index(), k -> new LinkedHashSet<>()).add(shard);
+        shardsByIndex.computeIfAbsent(shard.index(), k -> new HashSet<>()).add(shard);
         assert invariant();
     }
 
@@ -154,16 +156,14 @@ void update(ShardRouting oldShard, ShardRouting newShard) {
             boolean exist = relocatingShards.remove(oldShard);
             assert exist : "expected shard " + oldShard + " to exist in relocatingShards";
         }
-        shardsByIndex.get(oldShard.index()).remove(oldShard);
-        if (shardsByIndex.get(oldShard.index()).isEmpty()) {
-            shardsByIndex.remove(oldShard.index());
-        }
+        final Set<ShardRouting> byIndex = shardsByIndex.get(oldShard.index());
+        byIndex.remove(oldShard);
+        byIndex.add(newShard);
         if (newShard.initializing()) {
             initializingShards.add(newShard);
         } else if (newShard.relocating()) {
             relocatingShards.add(newShard);
         }
-        shardsByIndex.computeIfAbsent(newShard.index(), k -> new LinkedHashSet<>()).add(newShard);
         assert invariant();
     }
 
@@ -178,8 +178,9 @@ void remove(ShardRouting shard) {
             boolean exist = relocatingShards.remove(shard);
             assert exist : "expected shard " + shard + " to exist in relocatingShards";
         }
-        shardsByIndex.get(shard.index()).remove(shard);
-        if (shardsByIndex.get(shard.index()).isEmpty()) {
+        final Set<ShardRouting> byIndex = shardsByIndex.get(shard.index());
+        byIndex.remove(shard);
+        if (byIndex.isEmpty()) {
             shardsByIndex.remove(shard.index());
         }
         assert invariant();
@@ -285,7 +286,7 @@ public int numberOfOwningShards() {
     }
 
     public int numberOfOwningShardsForIndex(final Index index) {
-        final LinkedHashSet<ShardRouting> shardRoutings = shardsByIndex.get(index);
+        final Set<ShardRouting> shardRoutings = shardsByIndex.get(index);
         if (shardRoutings == null) {
             return 0;
         } else {