Optimize parsing of compound format in MergePolicyConfig (elastic#135643)

By checking if the setting value ends with a `b`, we can skip the ratio/double parsing. The default value is `1gb`, so this will skip the ratio parsing by default.
I was doing some benchmarking on component templates and noticed the `MergePolicyConfig` constructor sticking out slightly in flamegraphs due to the failing double parsing.

Author: nielsbauman

server/src/main/java/org/elasticsearch/index/MergePolicyConfig.java

@@ -14,6 +14,7 @@
 import org.apache.lucene.index.MergePolicy;
 import org.apache.lucene.index.NoMergePolicy;
 import org.apache.lucene.index.TieredMergePolicy;
+import org.elasticsearch.ElasticsearchParseException;
 import org.elasticsearch.common.settings.Setting;
 import org.elasticsearch.common.settings.Setting.Property;
 import org.elasticsearch.common.unit.ByteSizeUnit;
@@ -398,26 +399,32 @@ private static CompoundFileThreshold parseCompoundFormat(String noCFSRatio) {
             return new CompoundFileThreshold(1.0d);
         } else if (noCFSRatio.equalsIgnoreCase("false")) {
             return new CompoundFileThreshold(0.0d);
-        } else {
+        }
+        NumberFormatException suppressedNfe = null;
+        if (noCFSRatio.endsWith("b") == false) {
+            // If the value ends with a `b`, it implies it is probably a byte size value, so do not try to parse as a ratio at all.
+            // The main motivation is to make parsing faster. Using exception throwing and catching when trying to parse
+            // as a ratio as a means of identifying that a string is not a ratio can be quite slow.
             try {
-                try {
-                    return new CompoundFileThreshold(Double.parseDouble(noCFSRatio));
-                } catch (NumberFormatException ex) {
-                    throw new IllegalArgumentException(
-                        "index.compound_format must be a boolean, a non-negative byte size or a ratio in the interval [0..1] but was: ["
-                            + noCFSRatio
-                            + "]",
-                        ex
-                    );
-                }
-            } catch (IllegalArgumentException e) {
-                try {
-                    return new CompoundFileThreshold(ByteSizeValue.parseBytesSizeValue(noCFSRatio, INDEX_COMPOUND_FORMAT_SETTING_KEY));
-                } catch (RuntimeException e2) {
-                    e.addSuppressed(e2);
-                }
-                throw e;
+                return new CompoundFileThreshold(Double.parseDouble(noCFSRatio));
+            } catch (NumberFormatException e) {
+                // ignore for now, see if it parses as bytes
+                suppressedNfe = e;
+            }
+        }
+        try {
+            return new CompoundFileThreshold(ByteSizeValue.parseBytesSizeValue(noCFSRatio, INDEX_COMPOUND_FORMAT_SETTING_KEY));
+        } catch (ElasticsearchParseException ex) {
+            final var illegalArgumentException = new IllegalArgumentException(
+                "index.compound_format must be a boolean, a non-negative byte size or a ratio in the interval [0..1] but was: ["
+                    + noCFSRatio
+                    + "]",
+                ex
+            );
+            if (suppressedNfe != null) {
+                illegalArgumentException.addSuppressed(suppressedNfe);
             }
+            throw illegalArgumentException;
         }
     }
 

server/src/test/java/org/elasticsearch/index/MergePolicyConfigTests.java

@@ -50,6 +50,12 @@ public void testCompoundFileSettings() throws IOException {
         assertCompoundThreshold(build(0.0), 0.0, ByteSizeValue.ofBytes(Long.MAX_VALUE));
         assertCompoundThreshold(build(0.0), 0.0, ByteSizeValue.ofBytes(Long.MAX_VALUE));
         assertCompoundThreshold(build("100MB"), 1.0, ByteSizeValue.ofMb(100));
+        assertCompoundThreshold(build(" 1gb"), 1.0, ByteSizeValue.ofGb(1));
+        assertCompoundThreshold(build(" 1gb "), 1.0, ByteSizeValue.ofGb(1));
+        assertCompoundThreshold(build("1k"), 1.0, ByteSizeValue.ofKb(1));
+        assertCompoundThreshold(build("1t"), 1.0, ByteSizeValue.ofTb(1));
+        assertCompoundThreshold(build(" 0"), 0, ByteSizeValue.ofBytes(Long.MAX_VALUE));
+        assertCompoundThreshold(build(" 0 "), 0, ByteSizeValue.ofBytes(Long.MAX_VALUE));
         assertCompoundThreshold(build("0MB"), 1.0, ByteSizeValue.ofBytes(0));
         assertCompoundThreshold(build("0B"), 1.0, ByteSizeValue.ofBytes(0));
     }