Merge branch 'main' into esql-exphisto-median-tests

Author: JonasKunz

.buildkite/pipelines/periodic-java-ea.yml

@@ -385,8 +385,8 @@ steps:
             - signal_reason: agent_stop
               limit: 3
 
-      - label: 9.0.7 / bwc
-        command: .ci/scripts/run-gradle.sh -Druntime.java=$$JAVA_EA_VERSION -Dbwc.checkout.align=true v9.0.7#bwcTest
+      - label: 9.0.8 / bwc
+        command: .ci/scripts/run-gradle.sh -Druntime.java=$$JAVA_EA_VERSION -Dbwc.checkout.align=true v9.0.8#bwcTest
         timeout_in_minutes: 300
         agents:
           provider: gcp
@@ -395,7 +395,7 @@ steps:
           buildDirectory: /dev/shm/bk
           preemptible: true
         env:
-          BWC_VERSION: 9.0.7
+          BWC_VERSION: 9.0.8
         retry:
           automatic:
             - exit_status: "-1"

.buildkite/pipelines/periodic-packaging.yml

@@ -352,8 +352,8 @@ steps:
         env:
           BWC_VERSION: 8.19.8
 
-      - label: "{{matrix.image}} / 9.0.7 / packaging-tests-upgrade"
-        command: ./.ci/scripts/packaging-test.sh -Dbwc.checkout.align=true destructiveDistroUpgradeTest.v9.0.7
+      - label: "{{matrix.image}} / 9.0.8 / packaging-tests-upgrade"
+        command: ./.ci/scripts/packaging-test.sh -Dbwc.checkout.align=true destructiveDistroUpgradeTest.v9.0.8
         timeout_in_minutes: 300
         matrix:
           setup:
@@ -366,7 +366,7 @@ steps:
           machineType: custom-16-32768
           buildDirectory: /dev/shm/bk
         env:
-          BWC_VERSION: 9.0.7
+          BWC_VERSION: 9.0.8
 
       - label: "{{matrix.image}} / 9.1.8 / packaging-tests-upgrade"
         command: ./.ci/scripts/packaging-test.sh -Dbwc.checkout.align=true destructiveDistroUpgradeTest.v9.1.8

.buildkite/pipelines/periodic.yml

@@ -382,8 +382,8 @@ steps:
             - signal_reason: agent_stop
               limit: 3
 
-      - label: 9.0.7 / bwc
-        command: .ci/scripts/run-gradle.sh --continue -Dbwc.checkout.align=true v9.0.7#bwcTest
+      - label: 9.0.8 / bwc
+        command: .ci/scripts/run-gradle.sh --continue -Dbwc.checkout.align=true v9.0.8#bwcTest
         timeout_in_minutes: 300
         agents:
           provider: gcp
@@ -392,7 +392,7 @@ steps:
           buildDirectory: /dev/shm/bk
           preemptible: true
         env:
-          BWC_VERSION: 9.0.7
+          BWC_VERSION: 9.0.8
         retry:
           automatic:
             - exit_status: "-1"

.ci/bwcVersions

@@ -19,7 +19,7 @@ BWC_VERSION:
   - "8.17.10"
   - "8.18.8"
   - "8.19.8"
-  - "9.0.7"
+  - "9.0.8"
   - "9.1.8"
   - "9.2.2"
   - "9.3.0"

benchmarks/src/main/java/org/elasticsearch/benchmark/vector/scorer/BenchmarkUtils.java

@@ -0,0 +1,94 @@
+/*
+ * 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.vector.scorer;
+
+import org.apache.lucene.codecs.lucene99.Lucene99ScalarQuantizedVectorScorer;
+import org.apache.lucene.codecs.lucene99.OffHeapQuantizedByteVectorValues;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.MemorySegmentAccessInput;
+import org.apache.lucene.util.hnsw.RandomVectorScorer;
+import org.apache.lucene.util.hnsw.RandomVectorScorerSupplier;
+import org.apache.lucene.util.quantization.QuantizedByteVectorValues;
+import org.apache.lucene.util.quantization.ScalarQuantizer;
+import org.elasticsearch.simdvec.VectorScorerFactory;
+
+import java.io.IOException;
+import java.util.concurrent.ThreadLocalRandom;
+
+class BenchmarkUtils {
+    // Unsigned int7 byte vectors have values in the range of 0 to 127 (inclusive).
+    static final byte MIN_INT7_VALUE = 0;
+    static final byte MAX_INT7_VALUE = 127;
+
+    static void randomInt7BytesBetween(byte[] bytes) {
+        var random = ThreadLocalRandom.current();
+        for (int i = 0, len = bytes.length; i < len;) {
+            bytes[i++] = (byte) random.nextInt(MIN_INT7_VALUE, MAX_INT7_VALUE + 1);
+        }
+    }
+
+    static void createRandomInt7VectorData(ThreadLocalRandom random, Directory dir, int dims, int numVectors) throws IOException {
+        try (IndexOutput out = dir.createOutput("vector.data", IOContext.DEFAULT)) {
+            var vec = new byte[dims];
+            for (int v = 0; v < numVectors; v++) {
+                randomInt7BytesBetween(vec);
+                var vecOffset = random.nextFloat();
+                out.writeBytes(vec, 0, vec.length);
+                out.writeInt(Float.floatToIntBits(vecOffset));
+            }
+        }
+    }
+
+    static VectorScorerFactory getScorerFactoryOrDie() {
+        var optionalVectorScorerFactory = VectorScorerFactory.instance();
+        if (optionalVectorScorerFactory.isEmpty()) {
+            String msg = "JDK=["
+                + Runtime.version()
+                + "], os.name=["
+                + System.getProperty("os.name")
+                + "], os.arch=["
+                + System.getProperty("os.arch")
+                + "]";
+            throw new AssertionError("Vector scorer factory not present. Cannot run the benchmark. " + msg);
+        }
+        return optionalVectorScorerFactory.get();
+    }
+
+    static boolean supportsHeapSegments() {
+        return Runtime.version().feature() >= 22;
+    }
+
+    static QuantizedByteVectorValues vectorValues(int dims, int size, IndexInput in, VectorSimilarityFunction sim) throws IOException {
+        var sq = new ScalarQuantizer(0.1f, 0.9f, (byte) 7);
+        var slice = in.slice("values", 0, in.length());
+        return new OffHeapQuantizedByteVectorValues.DenseOffHeapVectorValues(dims, size, sq, false, sim, null, slice);
+    }
+
+    static RandomVectorScorerSupplier luceneScoreSupplier(QuantizedByteVectorValues values, VectorSimilarityFunction sim)
+        throws IOException {
+        return new Lucene99ScalarQuantizedVectorScorer(null).getRandomVectorScorerSupplier(sim, values);
+    }
+
+    static RandomVectorScorer luceneScorer(QuantizedByteVectorValues values, VectorSimilarityFunction sim, float[] queryVec)
+        throws IOException {
+        return new Lucene99ScalarQuantizedVectorScorer(null).getRandomVectorScorer(sim, values, queryVec);
+    }
+
+    static float readNodeCorrectionConstant(QuantizedByteVectorValues values, int targetOrd) throws IOException {
+        var vectorByteSize = values.getVectorByteLength();
+        var input = (MemorySegmentAccessInput) values.getSlice();
+        long byteOffset = (long) targetOrd * (vectorByteSize + Float.BYTES);
+        return Float.intBitsToFloat(input.readInt(byteOffset + vectorByteSize));
+    }
+}

benchmarks/src/main/java/org/elasticsearch/benchmark/vector/scorer/VectorScorerInt7uBenchmark.java

@@ -9,19 +9,13 @@
 
 package org.elasticsearch.benchmark.vector.scorer;
 
-import org.apache.lucene.codecs.lucene99.Lucene99ScalarQuantizedVectorScorer;
-import org.apache.lucene.codecs.lucene99.OffHeapQuantizedByteVectorValues;
 import org.apache.lucene.index.VectorSimilarityFunction;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.IOContext;
 import org.apache.lucene.store.IndexInput;
-import org.apache.lucene.store.IndexOutput;
 import org.apache.lucene.store.MMapDirectory;
 import org.apache.lucene.util.hnsw.RandomVectorScorer;
-import org.apache.lucene.util.hnsw.RandomVectorScorerSupplier;
 import org.apache.lucene.util.hnsw.UpdateableRandomVectorScorer;
-import org.apache.lucene.util.quantization.QuantizedByteVectorValues;
-import org.apache.lucene.util.quantization.ScalarQuantizer;
 import org.elasticsearch.common.logging.LogConfigurator;
 import org.elasticsearch.core.IOUtils;
 import org.elasticsearch.logging.LogManager;
@@ -42,23 +36,31 @@
 
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 
+import static org.elasticsearch.benchmark.vector.scorer.BenchmarkUtils.createRandomInt7VectorData;
+import static org.elasticsearch.benchmark.vector.scorer.BenchmarkUtils.getScorerFactoryOrDie;
+import static org.elasticsearch.benchmark.vector.scorer.BenchmarkUtils.luceneScoreSupplier;
+import static org.elasticsearch.benchmark.vector.scorer.BenchmarkUtils.luceneScorer;
+import static org.elasticsearch.benchmark.vector.scorer.BenchmarkUtils.readNodeCorrectionConstant;
+import static org.elasticsearch.benchmark.vector.scorer.BenchmarkUtils.supportsHeapSegments;
+import static org.elasticsearch.benchmark.vector.scorer.BenchmarkUtils.vectorValues;
 import static org.elasticsearch.simdvec.VectorSimilarityType.DOT_PRODUCT;
 import static org.elasticsearch.simdvec.VectorSimilarityType.EUCLIDEAN;
 
+/**
+ * Benchmark that compares various scalar quantized vector similarity function
+ * implementations: scalar, lucene's panama-ized, and Elasticsearch's native.
+ * Run with ./gradlew -p benchmarks run --args 'VectorScorerInt7uBenchmark'
+ */
 @Fork(value = 1, jvmArgsPrepend = { "--add-modules=jdk.incubator.vector" })
 @Warmup(iterations = 3, time = 3)
 @Measurement(iterations = 5, time = 3)
 @BenchmarkMode(Mode.Throughput)
 @OutputTimeUnit(TimeUnit.MICROSECONDS)
 @State(Scope.Thread)
-/**
- * Benchmark that compares various scalar quantized vector similarity function
- * implementations;: scalar, lucene's panama-ized, and Elasticsearch's native.
- * Run with ./gradlew -p benchmarks run --args 'Int7uScorerBenchmark'
- */
 public class VectorScorerInt7uBenchmark {
 
     static {
@@ -71,15 +73,16 @@ public class VectorScorerInt7uBenchmark {
 
     @Param({ "96", "768", "1024" })
     public int dims;
-    final int size = 2; // there are only two vectors to compare
+    public int numVectors = 2; // there are only two vectors to compare
 
+    Path path;
     Directory dir;
     IndexInput in;
     VectorScorerFactory factory;
 
     byte[] vec1, vec2;
-    float vec1Offset;
-    float vec2Offset;
+    float vec1CorrectionConstant;
+    float vec2CorrectionConstant;
     float scoreCorrectionConstant;
 
     UpdateableRandomVectorScorer luceneDotScorer;
@@ -94,45 +97,34 @@ public class VectorScorerInt7uBenchmark {
 
     @Setup
     public void setup() throws IOException {
-        var optionalVectorScorerFactory = VectorScorerFactory.instance();
-        if (optionalVectorScorerFactory.isEmpty()) {
-            String msg = "JDK=["
-                + Runtime.version()
-                + "], os.name=["
-                + System.getProperty("os.name")
-                + "], os.arch=["
-                + System.getProperty("os.arch")
-                + "]";
-            throw new AssertionError("Vector scorer factory not present. Cannot run the benchmark. " + msg);
-        }
-        factory = optionalVectorScorerFactory.get();
-        vec1 = new byte[dims];
-        vec2 = new byte[dims];
-
-        randomInt7BytesBetween(vec1);
-        randomInt7BytesBetween(vec2);
-        vec1Offset = ThreadLocalRandom.current().nextFloat();
-        vec2Offset = ThreadLocalRandom.current().nextFloat();
-
-        dir = new MMapDirectory(Files.createTempDirectory("nativeScalarQuantBench"));
-        try (IndexOutput out = dir.createOutput("vector.data", IOContext.DEFAULT)) {
-            out.writeBytes(vec1, 0, vec1.length);
-            out.writeInt(Float.floatToIntBits(vec1Offset));
-            out.writeBytes(vec2, 0, vec2.length);
-            out.writeInt(Float.floatToIntBits(vec2Offset));
-        }
+        factory = getScorerFactoryOrDie();
+
+        var random = ThreadLocalRandom.current();
+        path = Files.createTempDirectory("Int7uScorerBenchmark");
+        dir = new MMapDirectory(path);
+        createRandomInt7VectorData(random, dir, dims, numVectors);
+
         in = dir.openInput("vector.data", IOContext.DEFAULT);
-        var values = vectorValues(dims, 2, in, VectorSimilarityFunction.DOT_PRODUCT);
-        scoreCorrectionConstant = values.getScalarQuantizer().getConstantMultiplier();
-        luceneDotScorer = luceneScoreSupplier(values, VectorSimilarityFunction.DOT_PRODUCT).scorer();
+        final var dotProductValues = vectorValues(dims, numVectors, in, VectorSimilarityFunction.DOT_PRODUCT);
+        scoreCorrectionConstant = dotProductValues.getScalarQuantizer().getConstantMultiplier();
+        luceneDotScorer = luceneScoreSupplier(dotProductValues, VectorSimilarityFunction.DOT_PRODUCT).scorer();
         luceneDotScorer.setScoringOrdinal(0);
-        values = vectorValues(dims, 2, in, VectorSimilarityFunction.EUCLIDEAN);
-        luceneSqrScorer = luceneScoreSupplier(values, VectorSimilarityFunction.EUCLIDEAN).scorer();
-        luceneSqrScorer.setScoringOrdinal(0);
-
-        nativeDotScorer = factory.getInt7SQVectorScorerSupplier(DOT_PRODUCT, in, values, scoreCorrectionConstant).get().scorer();
+        nativeDotScorer = factory.getInt7SQVectorScorerSupplier(DOT_PRODUCT, in, dotProductValues, scoreCorrectionConstant)
+            .orElseThrow()
+            .scorer();
         nativeDotScorer.setScoringOrdinal(0);
-        nativeSqrScorer = factory.getInt7SQVectorScorerSupplier(EUCLIDEAN, in, values, scoreCorrectionConstant).get().scorer();
+
+        vec1 = dotProductValues.vectorValue(0).clone();
+        vec1CorrectionConstant = readNodeCorrectionConstant(dotProductValues, 0);
+        vec2 = dotProductValues.vectorValue(1).clone();
+        vec2CorrectionConstant = readNodeCorrectionConstant(dotProductValues, 1);
+
+        final var euclideanValues = vectorValues(dims, numVectors, in, VectorSimilarityFunction.EUCLIDEAN);
+        luceneSqrScorer = luceneScoreSupplier(euclideanValues, VectorSimilarityFunction.EUCLIDEAN).scorer();
+        luceneSqrScorer.setScoringOrdinal(0);
+        nativeSqrScorer = factory.getInt7SQVectorScorerSupplier(EUCLIDEAN, in, euclideanValues, scoreCorrectionConstant)
+            .orElseThrow()
+            .scorer();
         nativeSqrScorer.setScoringOrdinal(0);
 
         if (supportsHeapSegments()) {
@@ -141,16 +133,19 @@ public void setup() throws IOException {
             for (int i = 0; i < dims; i++) {
                 queryVec[i] = ThreadLocalRandom.current().nextFloat();
             }
-            luceneDotScorerQuery = luceneScorer(values, VectorSimilarityFunction.DOT_PRODUCT, queryVec);
-            nativeDotScorerQuery = factory.getInt7SQVectorScorer(VectorSimilarityFunction.DOT_PRODUCT, values, queryVec).get();
-            luceneSqrScorerQuery = luceneScorer(values, VectorSimilarityFunction.EUCLIDEAN, queryVec);
-            nativeSqrScorerQuery = factory.getInt7SQVectorScorer(VectorSimilarityFunction.EUCLIDEAN, values, queryVec).get();
+            luceneDotScorerQuery = luceneScorer(dotProductValues, VectorSimilarityFunction.DOT_PRODUCT, queryVec);
+            nativeDotScorerQuery = factory.getInt7SQVectorScorer(VectorSimilarityFunction.DOT_PRODUCT, dotProductValues, queryVec)
+                .orElseThrow();
+            luceneSqrScorerQuery = luceneScorer(euclideanValues, VectorSimilarityFunction.EUCLIDEAN, queryVec);
+            nativeSqrScorerQuery = factory.getInt7SQVectorScorer(VectorSimilarityFunction.EUCLIDEAN, euclideanValues, queryVec)
+                .orElseThrow();
         }
     }
 
     @TearDown
     public void teardown() throws IOException {
         IOUtils.close(dir, in);
+        IOUtils.rm(path);
     }
 
     @Benchmark
@@ -169,7 +164,7 @@ public float dotProductScalar() {
         for (int i = 0; i < vec1.length; i++) {
             dotProduct += vec1[i] * vec2[i];
         }
-        float adjustedDistance = dotProduct * scoreCorrectionConstant + vec1Offset + vec2Offset;
+        float adjustedDistance = dotProduct * scoreCorrectionConstant + vec1CorrectionConstant + vec2CorrectionConstant;
         return (1 + adjustedDistance) / 2;
     }
 
@@ -215,33 +210,4 @@ public float squareDistanceLuceneQuery() throws IOException {
     public float squareDistanceNativeQuery() throws IOException {
         return nativeSqrScorerQuery.score(1);
     }
-
-    static boolean supportsHeapSegments() {
-        return Runtime.version().feature() >= 22;
-    }
-
-    QuantizedByteVectorValues vectorValues(int dims, int size, IndexInput in, VectorSimilarityFunction sim) throws IOException {
-        var sq = new ScalarQuantizer(0.1f, 0.9f, (byte) 7);
-        var slice = in.slice("values", 0, in.length());
-        return new OffHeapQuantizedByteVectorValues.DenseOffHeapVectorValues(dims, size, sq, false, sim, null, slice);
-    }
-
-    RandomVectorScorerSupplier luceneScoreSupplier(QuantizedByteVectorValues values, VectorSimilarityFunction sim) throws IOException {
-        return new Lucene99ScalarQuantizedVectorScorer(null).getRandomVectorScorerSupplier(sim, values);
-    }
-
-    RandomVectorScorer luceneScorer(QuantizedByteVectorValues values, VectorSimilarityFunction sim, float[] queryVec) throws IOException {
-        return new Lucene99ScalarQuantizedVectorScorer(null).getRandomVectorScorer(sim, values, queryVec);
-    }
-
-    // Unsigned int7 byte vectors have values in the range of 0 to 127 (inclusive).
-    static final byte MIN_INT7_VALUE = 0;
-    static final byte MAX_INT7_VALUE = 127;
-
-    static void randomInt7BytesBetween(byte[] bytes) {
-        var random = ThreadLocalRandom.current();
-        for (int i = 0, len = bytes.length; i < len;) {
-            bytes[i++] = (byte) random.nextInt(MIN_INT7_VALUE, MAX_INT7_VALUE + 1);
-        }
-    }
 }