Speedup ContextIndexSearcher

We can do a little better here and create less garbage + save cycles for
method calls when doing all the sorting.

Author: original-brownbear

server/src/main/java/org/elasticsearch/search/internal/ContextIndexSearcher.java

@@ -49,7 +49,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
 import java.util.PriorityQueue;
@@ -255,13 +254,11 @@ private static LeafSlice[] computeSlices(List<LeafReaderContext> leaves, int min
         // Make a copy so we can sort:
         List<LeafReaderContext> sortedLeaves = new ArrayList<>(leaves);
         // Sort by maxDoc, descending:
-        final Comparator<LeafReaderContext> leafComparator = Comparator.comparingInt(l -> l.reader().maxDoc());
-        sortedLeaves.sort(leafComparator.reversed());
+        sortedLeaves.sort((c1, c2) -> Integer.compare(c2.reader().maxDoc(), c1.reader().maxDoc()));
         // we add the groups on a priority queue, so we can add orphan leafs to the smallest group
-        final Comparator<List<LeafReaderContext>> groupComparator = Comparator.comparingInt(
-            l -> l.stream().mapToInt(lr -> lr.reader().maxDoc()).sum()
+        final PriorityQueue<List<LeafReaderContext>> queue = new PriorityQueue<>(
+            (c1, c2) -> Integer.compare(sumMaxDocValues(c1), sumMaxDocValues(c2))
         );
-        final PriorityQueue<List<LeafReaderContext>> queue = new PriorityQueue<>(groupComparator);
         long docSum = 0;
         List<LeafReaderContext> group = new ArrayList<>();
         for (LeafReaderContext ctx : sortedLeaves) {
@@ -297,6 +294,14 @@ private static LeafSlice[] computeSlices(List<LeafReaderContext> leaves, int min
         return slices;
     }
 
+    private static int sumMaxDocValues(List<LeafReaderContext> l) {
+        int sum = 0;
+        for (LeafReaderContext lr : l) {
+            sum += lr.reader().maxDoc();
+        }
+        return sum;
+    }
+
     @Override
     public <C extends Collector, T> T search(Query query, CollectorManager<C, T> collectorManager) throws IOException {
         final C firstCollector = collectorManager.newCollector();
@@ -337,7 +342,7 @@ private <C extends Collector, T> T search(Weight weight, CollectorManager<C, T>
                     throw new IllegalStateException("CollectorManager does not always produce collectors with the same score mode");
                 }
             }
-            final List<Callable<C>> listTasks = new ArrayList<>();
+            final List<Callable<C>> listTasks = new ArrayList<>(leafSlices.length);
             for (int i = 0; i < leafSlices.length; ++i) {
                 final LeafReaderContext[] leaves = leafSlices[i].leaves;
                 final C collector = collectors.get(i);