Esql mv rerank

.github/updatecli/values.d/ironbank.yml

@@ -1,3 +1,3 @@
 config:
   - path: distribution/docker/src/docker/iron_bank
-    dockerfile: ../Dockerfile
+    dockerfile: ../dockerfiles/ironbank/Dockerfile

benchmarks/src/main/java/org/elasticsearch/benchmark/index/codec/tsdb/DecodeConstantIntegerBenchmark.java

@@ -41,7 +41,6 @@
 @State(Scope.Benchmark)
 public class DecodeConstantIntegerBenchmark {
     private static final int SEED = 17;
-    private static final int BLOCK_SIZE = 128;
 
     @Param({ "1", "4", "8", "9", "16", "17", "24", "25", "32", "33", "40", "48", "56", "57", "64" })
     private int bitsPerValue;
@@ -59,12 +58,12 @@ public void setupInvocation() throws IOException {
 
     @Setup(Level.Trial)
     public void setupTrial() throws IOException {
-        decode.setupTrial(new ConstantIntegerSupplier(SEED, bitsPerValue, BLOCK_SIZE));
+        decode.setupTrial(new ConstantIntegerSupplier(SEED, bitsPerValue, decode.getBlockSize()));
     }
 
     @Benchmark
     public void throughput(Blackhole bh, ThroughputMetrics metrics) throws IOException {
         decode.benchmark(bh);
-        metrics.recordOperation(BLOCK_SIZE, decode.getEncodedSize());
+        metrics.recordOperation(decode.getBlockSize(), decode.getEncodedSize());
     }
 }

benchmarks/src/main/java/org/elasticsearch/benchmark/index/codec/tsdb/DecodeCounterWithResetsBenchmark.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.benchmark.index.codec.tsdb;
+
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.AbstractTSDBCodecBenchmark;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.CounterWithResetsSupplier;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.DecodeBenchmark;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.ThroughputMetrics;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Benchmark for decoding counter-with-resets data patterns.
+ *
+ * <p>Parameterized by resetProbability to test how reset frequency affects
+ * decoding performance. Lower probability means longer monotonic runs between
+ * resets, while higher probability creates more frequent jumps back to zero.
+ */
+@Fork(value = 1)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@State(Scope.Benchmark)
+public class DecodeCounterWithResetsBenchmark {
+    private static final int SEED = 17;
+
+    @Param({ "0.01", "0.02", "0.05" })
+    private double resetProbability;
+
+    private final AbstractTSDBCodecBenchmark decode;
+
+    public DecodeCounterWithResetsBenchmark() {
+        this.decode = new DecodeBenchmark();
+    }
+
+    @Setup(Level.Invocation)
+    public void setupInvocation() throws IOException {
+        decode.setupInvocation();
+    }
+
+    @Setup(Level.Trial)
+    public void setupTrial() throws IOException {
+        decode.setupTrial(CounterWithResetsSupplier.builder(SEED, decode.getBlockSize()).withResetProbability(resetProbability).build());
+    }
+
+    @Benchmark
+    public void throughput(Blackhole bh, ThroughputMetrics metrics) throws IOException {
+        decode.benchmark(bh);
+        metrics.recordOperation(decode.getBlockSize(), decode.getEncodedSize());
+    }
+}

benchmarks/src/main/java/org/elasticsearch/benchmark/index/codec/tsdb/DecodeDecreasingIntegerBenchmark.java

@@ -41,7 +41,6 @@
 @State(Scope.Benchmark)
 public class DecodeDecreasingIntegerBenchmark {
     private static final int SEED = 17;
-    private static final int BLOCK_SIZE = 128;
 
     @Param({ "1", "4", "8", "9", "16", "17", "24", "25", "32", "33", "40", "48", "56", "57", "64" })
     private int bitsPerValue;
@@ -59,12 +58,12 @@ public void setupInvocation() throws IOException {
 
     @Setup(Level.Trial)
     public void setupTrial() throws IOException {
-        decode.setupTrial(new DecreasingIntegerSupplier(SEED, bitsPerValue, BLOCK_SIZE));
+        decode.setupTrial(new DecreasingIntegerSupplier(SEED, bitsPerValue, decode.getBlockSize()));
     }
 
     @Benchmark
     public void throughput(Blackhole bh, ThroughputMetrics metrics) throws IOException {
         decode.benchmark(bh);
-        metrics.recordOperation(BLOCK_SIZE, decode.getEncodedSize());
+        metrics.recordOperation(decode.getBlockSize(), decode.getEncodedSize());
     }
 }

benchmarks/src/main/java/org/elasticsearch/benchmark/index/codec/tsdb/DecodeGaugeLikeBenchmark.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.benchmark.index.codec.tsdb;
+
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.AbstractTSDBCodecBenchmark;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.DecodeBenchmark;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.GaugeLikeSupplier;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.ThroughputMetrics;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Benchmark for decoding gauge-like data patterns.
+ *
+ * <p>Parameterized by varianceRatio to test how different fluctuation intensities
+ * affect decoding performance. Lower variance means values stay closer to the baseline,
+ * while higher variance creates more volatile oscillations.
+ */
+@Fork(value = 1)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@State(Scope.Benchmark)
+public class DecodeGaugeLikeBenchmark {
+    private static final int SEED = 17;
+
+    @Param({ "0.05", "0.1", "0.2" })
+    private double varianceRatio;
+
+    private final AbstractTSDBCodecBenchmark decode;
+
+    public DecodeGaugeLikeBenchmark() {
+        this.decode = new DecodeBenchmark();
+    }
+
+    @Setup(Level.Invocation)
+    public void setupInvocation() throws IOException {
+        decode.setupInvocation();
+    }
+
+    @Setup(Level.Trial)
+    public void setupTrial() throws IOException {
+        decode.setupTrial(GaugeLikeSupplier.builder(SEED, decode.getBlockSize()).withVarianceRatio(varianceRatio).build());
+    }
+
+    @Benchmark
+    public void throughput(Blackhole bh, ThroughputMetrics metrics) throws IOException {
+        decode.benchmark(bh);
+        metrics.recordOperation(decode.getBlockSize(), decode.getEncodedSize());
+    }
+}

benchmarks/src/main/java/org/elasticsearch/benchmark/index/codec/tsdb/DecodeGcdFriendlyBenchmark.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.benchmark.index.codec.tsdb;
+
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.AbstractTSDBCodecBenchmark;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.DecodeBenchmark;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.GcdFriendlySupplier;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.ThroughputMetrics;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Benchmark for decoding GCD-friendly data patterns.
+ *
+ * <p>Parameterized by GCD value to test how the GCD compression stage handles
+ * different divisors: 1 (no GCD benefit), small primes (7, 127), powers of 2
+ * (64, 1024), and common values (100, 1000).
+ */
+@Fork(value = 1)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@State(Scope.Benchmark)
+public class DecodeGcdFriendlyBenchmark {
+    private static final int SEED = 17;
+
+    @Param({ "1", "7", "64", "100", "127", "1000", "1024" })
+    private long gcd;
+
+    private final AbstractTSDBCodecBenchmark decode;
+
+    public DecodeGcdFriendlyBenchmark() {
+        this.decode = new DecodeBenchmark();
+    }
+
+    @Setup(Level.Invocation)
+    public void setupInvocation() throws IOException {
+        decode.setupInvocation();
+    }
+
+    @Setup(Level.Trial)
+    public void setupTrial() throws IOException {
+        decode.setupTrial(GcdFriendlySupplier.builder(SEED, decode.getBlockSize()).withGcd(gcd).build());
+    }
+
+    @Benchmark
+    public void throughput(Blackhole bh, ThroughputMetrics metrics) throws IOException {
+        decode.benchmark(bh);
+        metrics.recordOperation(decode.getBlockSize(), decode.getEncodedSize());
+    }
+}

benchmarks/src/main/java/org/elasticsearch/benchmark/index/codec/tsdb/DecodeIncreasingIntegerBenchmark.java

@@ -41,7 +41,6 @@
 @State(Scope.Benchmark)
 public class DecodeIncreasingIntegerBenchmark {
     private static final int SEED = 17;
-    private static final int BLOCK_SIZE = 128;
 
     @Param({ "1", "4", "8", "9", "16", "17", "24", "25", "32", "33", "40", "48", "56", "57", "64" })
     private int bitsPerValue;
@@ -59,12 +58,12 @@ public void setupInvocation() throws IOException {
 
     @Setup(Level.Trial)
     public void setupTrial() throws IOException {
-        decode.setupTrial(new IncreasingIntegerSupplier(SEED, bitsPerValue, BLOCK_SIZE));
+        decode.setupTrial(new IncreasingIntegerSupplier(SEED, bitsPerValue, decode.getBlockSize()));
     }
 
     @Benchmark
     public void throughput(Blackhole bh, ThroughputMetrics metrics) throws IOException {
         decode.benchmark(bh);
-        metrics.recordOperation(BLOCK_SIZE, decode.getEncodedSize());
+        metrics.recordOperation(decode.getBlockSize(), decode.getEncodedSize());
     }
 }

benchmarks/src/main/java/org/elasticsearch/benchmark/index/codec/tsdb/DecodeLowCardinalityBenchmark.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.benchmark.index.codec.tsdb;
+
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.AbstractTSDBCodecBenchmark;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.DecodeBenchmark;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.LowCardinalitySupplier;
+import org.elasticsearch.benchmark.index.codec.tsdb.internal.ThroughputMetrics;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Benchmark for decoding low cardinality data patterns.
+ *
+ * <p>Parameterized by number of distinct values and Zipf skew to test how
+ * the decoder handles data with limited value diversity. Higher skew means
+ * the most frequent value dominates more strongly.
+ */
+@Fork(value = 1)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@State(Scope.Benchmark)
+public class DecodeLowCardinalityBenchmark {
+    private static final int SEED = 17;
+
+    @Param({ "5", "10" })
+    private int distinctValues;
+
+    @Param({ "1", "2", "3" })
+    private double skew;
+
+    private final AbstractTSDBCodecBenchmark decode;
+
+    public DecodeLowCardinalityBenchmark() {
+        this.decode = new DecodeBenchmark();
+    }
+
+    @Setup(Level.Invocation)
+    public void setupInvocation() throws IOException {
+        decode.setupInvocation();
+    }
+
+    @Setup(Level.Trial)
+    public void setupTrial() throws IOException {
+        decode.setupTrial(
+            LowCardinalitySupplier.builder(SEED, decode.getBlockSize()).withDistinctValues(distinctValues).withSkew(skew).build()
+        );
+    }
+
+    @Benchmark
+    public void throughput(Blackhole bh, ThroughputMetrics metrics) throws IOException {
+        decode.benchmark(bh);
+        metrics.recordOperation(decode.getBlockSize(), decode.getEncodedSize());
+    }
+}