Decrease TieredMergePolicy's default number of segments per tier to 8. (#14823)

`TieredMergePolicy` currently allows 10 segments per tier. With Lucene being
increasingly deployed with separate indexing and search tiers that get updated
via segment-based replication, I believe that it would make sense for Lucene to
have more aggressive merging defaults, a price that is only paid once on the
indexing tier, but that benefits all search nodes that serve queries for this
index.

Note that this is still a somewhat conservative default, applications with low
latency requirements and low update rates will likely want to go even further,
with 4 segments per tier, or even 2.

`BaseMergePolicyTestCase#testSimulateAppendOnly` reports a write amplification
increase from 3.4 to 3.8, while `BaseMergePolicyTestCase#testSimulateUpdates`
reports a write amplification increase from 4.5 to 4.9. In exchange, the number
of segments between the floor and max segment sizes decreases by about 20%.

This should especially help queries that have a high per-segment overhead:
PK lookups, point queries, multi-term queries and vector searches.

Author: jpountz

lucene/CHANGES.txt

@@ -194,6 +194,12 @@ Optimizations
 
 * GITHUB#14854: Using BatchScoreBulkScorer on CombinedFieldQuery. (Ge Song)
 
+Changes in Runtime Behavior
+---------------------
+* GITHUB#14823: Decrease TieredMergePolicy's default number of segments per
+  tier from 10 to 8. This is expected to result in slightly faster search and
+  slightly slower indexing. (Adrien Grand)
+
 Bug Fixes
 ---------------------
 * GITHUB#14654: ValueSource.fromDoubleValuesSource(dvs).getSortField() would throw errors when

lucene/core/src/java/org/apache/lucene/index/TieredMergePolicy.java

@@ -85,7 +85,7 @@ public class TieredMergePolicy extends MergePolicy {
   private long maxMergedSegmentBytes = 5 * 1024 * 1024 * 1024L;
 
   private long floorSegmentBytes = 16 * 1024 * 1024L;
-  private double segsPerTier = 10.0;
+  private double segsPerTier = 8.0;
   private double forceMergeDeletesPctAllowed = 10.0;
   private double deletesPctAllowed = 20.0;
   private int targetSearchConcurrency = 1;
@@ -217,7 +217,7 @@ public double getForceMergeDeletesPctAllowed() {
    * Sets the allowed number of segments per tier. Smaller values mean more merging but fewer
    * segments.
    *
-   * <p>Default is 10.0.
+   * <p>Default is 8.0.
    */
   public TieredMergePolicy setSegmentsPerTier(double v) {
     if (v < 2.0) {

lucene/core/src/test/org/apache/lucene/index/TestTieredMergePolicy.java

@@ -839,7 +839,7 @@ public void testUnbalancedMergeSelection() throws Exception {
     // Make sure TMP always merged equal-number-of-docs segments:
     for (LeafReaderContext ctx : r.leaves()) {
       int numDocs = ctx.reader().numDocs();
-      assertTrue("got numDocs=" + numDocs, numDocs == 100 || numDocs == 1000 || numDocs == 10000);
+      assertTrue("got numDocs=" + numDocs, numDocs == 100 || numDocs == 800 || numDocs == 6400);
     }
     r.close();
     w.close();
@@ -883,7 +883,7 @@ public void testManyMaxSizeSegments() throws IOException {
     assertNotNull(mergeSpec);
     assertEquals(1, mergeSpec.merges.size());
     OneMerge merge = mergeSpec.merges.get(0);
-    assertEquals(10, merge.segments.size());
+    assertEquals(8, merge.segments.size());
   }
 
   /** Make sure that singleton merges are considered when the max number of deletes is crossed. */
@@ -936,15 +936,15 @@ public void testMergeSizeIsLessThanFloorSize() throws IOException {
     MergeContext mergeContext = new MockMergeContext(SegmentCommitInfo::getDelCount);
 
     SegmentInfos infos = new SegmentInfos(Version.LATEST.major);
-    // 50 1MB segments
-    for (int i = 0; i < 50; ++i) {
+    // 5*mergeFactor 1MB segments
+    for (int i = 0; i < 5 * 8; ++i) {
       infos.add(makeSegmentCommitInfo("_0", 1_000_000, 0, 1, IndexWriter.SOURCE_FLUSH));
     }
 
     TieredMergePolicy mergePolicy = new TieredMergePolicy();
     mergePolicy.setFloorSegmentMB(0.1);
 
-    // Segments are above the floor segment size, we get 4 merges of mergeFactor=10 segments each
+    // Segments are above the floor segment size, we get 4 merges of mergeFactor=8 segments each
     MergeSpecification mergeSpec =
         mergePolicy.findMerges(MergeTrigger.FULL_FLUSH, infos, mergeContext);
     assertNotNull(mergeSpec);
@@ -953,23 +953,23 @@ public void testMergeSizeIsLessThanFloorSize() throws IOException {
       assertEquals(mergePolicy.getSegmentsPerTier(), oneMerge.segments.size(), 0d);
     }
 
-    // Segments are below the floor segment size and it takes 15 segments to go above the floor
-    // segment size. We get 3 merges of 15 segments each
-    mergePolicy.setFloorSegmentMB(15);
+    // Segments are below the floor segment size and it takes 12 segments to go above the floor
+    // segment size. We get 3 merges of 12 segments each.
+    mergePolicy.setFloorSegmentMB(12);
     mergeSpec = mergePolicy.findMerges(MergeTrigger.FULL_FLUSH, infos, mergeContext);
     assertNotNull(mergeSpec);
     assertEquals(3, mergeSpec.merges.size());
     for (OneMerge oneMerge : mergeSpec.merges) {
-      assertEquals(15, oneMerge.segments.size());
+      assertEquals(12, oneMerge.segments.size());
     }
 
-    // Segments are below the floor segment size. We get one merge that merges the 50 segments
+    // Segments are below the floor segment size. We get one merge that merges the 40 segments
     // together.
     mergePolicy.setFloorSegmentMB(60);
     mergeSpec = mergePolicy.findMerges(MergeTrigger.FULL_FLUSH, infos, mergeContext);
     assertNotNull(mergeSpec);
     assertEquals(1, mergeSpec.merges.size());
-    assertEquals(50, mergeSpec.merges.get(0).segments.size());
+    assertEquals(40, mergeSpec.merges.get(0).segments.size());
   }
 
   @SuppressWarnings("UnnecessaryAsync")