reducing memory usage

Author: masseyke

server/src/main/java/org/elasticsearch/indices/IndicesService.java

@@ -167,7 +167,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -521,65 +520,55 @@ static Map<Index, CommonStats> statsByIndex(final IndicesService indicesService,
 
     static Map<Index, List<IndexShardStats>> statsByShard(final IndicesService indicesService, final CommonStatsFlags flags) {
         IndicesQueryCache queryCache = indicesService.getIndicesQueryCache();
+        boolean hasQueryCache = queryCache != null;
         // First pass: gather all shards, cache sizes, and compute totals
-        class ShardCacheInfo {
-            final IndexService indexService;
-            final IndexShard indexShard;
-            final org.elasticsearch.index.shard.ShardId shardId;
-            final long cacheSize;
-
-            ShardCacheInfo(IndexService is, IndexShard shard, org.elasticsearch.index.shard.ShardId id, long size) {
-                this.indexService = is;
-                this.indexShard = shard;
-                this.shardId = id;
-                this.cacheSize = size;
-            }
-        }
-        List<ShardCacheInfo> shardInfos = new ArrayList<>();
         long totalSize = 0L;
         int shardCount = 0;
         boolean anyNonZero = false;
+        // First pass: compute totals only
         for (final IndexService indexService : indicesService) {
             for (final IndexShard indexShard : indexService) {
-                org.elasticsearch.index.shard.ShardId shardId = indexShard.shardId();
-                long cacheSize = queryCache.getCacheSizeForShard(shardId);
-                shardInfos.add(new ShardCacheInfo(indexService, indexShard, shardId, cacheSize));
+                long cacheSize = hasQueryCache ? queryCache.getCacheSizeForShard(indexShard.shardId()) : 0L;
                 shardCount++;
                 if (cacheSize > 0L) {
                     anyNonZero = true;
                     totalSize += cacheSize;
                 }
             }
         }
-        long sharedRamBytesUsed = queryCache.getSharedRamBytesUsed();
+        long sharedRamBytesUsed = hasQueryCache ? queryCache.getSharedRamBytesUsed() : 0L;
         final Map<Index, List<IndexShardStats>> statsByShard = new HashMap<>();
         // Second pass: build stats, compute shared RAM on the fly
-        for (ShardCacheInfo info : shardInfos) {
-            long sharedRam = 0L;
-            if (sharedRamBytesUsed != 0L) {
-                if (anyNonZero == false) {
-                    sharedRam = Math.round((double) sharedRamBytesUsed / shardCount);
-                } else if (totalSize != 0) {
-                    sharedRam = Math.round((double) sharedRamBytesUsed * info.cacheSize / totalSize);
-                }
-            }
-            try {
-                final IndexShardStats indexShardStats = indicesService.indexShardStats(
-                    indicesService,
-                    info.indexShard,
-                    flags,
-                    Collections.singletonMap(info.shardId, sharedRam)
-                );
-                if (indexShardStats == null) {
-                    continue;
+        for (final IndexService indexService : indicesService) {
+            for (final IndexShard indexShard : indexService) {
+                org.elasticsearch.index.shard.ShardId shardId = indexShard.shardId();
+                long cacheSize = hasQueryCache ? queryCache.getCacheSizeForShard(shardId) : 0L;
+                long sharedRam = 0L;
+                if (sharedRamBytesUsed != 0L) {
+                    if (anyNonZero == false) {
+                        sharedRam = Math.round((double) sharedRamBytesUsed / shardCount);
+                    } else if (totalSize != 0) {
+                        sharedRam = Math.round((double) sharedRamBytesUsed * cacheSize / totalSize);
+                    }
                 }
-                if (statsByShard.containsKey(info.indexService.index()) == false) {
-                    statsByShard.put(info.indexService.index(), arrayAsArrayList(indexShardStats));
-                } else {
-                    statsByShard.get(info.indexService.index()).add(indexShardStats);
+                try {
+                    final IndexShardStats indexShardStats = indicesService.indexShardStats(
+                        indicesService,
+                        indexShard,
+                        flags,
+                        java.util.Collections.singletonMap(shardId, sharedRam)
+                    );
+                    if (indexShardStats == null) {
+                        continue;
+                    }
+                    if (statsByShard.containsKey(indexService.index()) == false) {
+                        statsByShard.put(indexService.index(), arrayAsArrayList(indexShardStats));
+                    } else {
+                        statsByShard.get(indexService.index()).add(indexShardStats);
+                    }
+                } catch (IllegalIndexShardStateException | AlreadyClosedException e) {
+                    logger.trace(() -> format("%s ignoring shard stats", shardId), e);
                 }
-            } catch (IllegalIndexShardStateException | AlreadyClosedException e) {
-                logger.trace(() -> format("%s ignoring shard stats", info.shardId), e);
             }
         }
         return statsByShard;