Fix AVX-512 fpclass mask to classify negative infinity as negative in MIP scoring. (#142514)

Fix AVX-512 fpclass mask to classify negative infinity as negative in MIP scoring.

The AVX-512 implementation of scaleMaxInnerProductScore in score_2.cpp used _mm512_fpclass_ps_mask(res, 0x40) to identify negative values. The mask 0x40 (bit 6) only matches "Negative Finite", missing negative infinity (bit 4, 0x10). When the raw score was -Infinity, the code took the wrong branch (1 + res = -Infinity) instead of the negative branch (1/(1 - res) = 0), diverging from both the AVX2 path (_CMP_LT_OQ correctly treats -Infinity < 0 as true) and the Java scalar scaleMaxInnerProductScore.

The fix changes the mask from 0x40 to 0x50 to also match negative infinity. A targeted regression test is added that forces raw scores to -Infinity via queryAdditionalCorrection and asserts scalar vs vectorized agreement.

Author: ChrisHegarty

docs/changelog/142514.yaml

@@ -0,0 +1,7 @@
+area: Vector Search
+issues:
+ - 142289
+pr: 142514
+summary: Fix AVX-512 fpclass mask to classify negative infinity as negative in MIP
+  scoring
+type: bug

libs/native/libraries/build.gradle

@@ -19,7 +19,7 @@ configurations {
 }
 
 var zstdVersion = "1.5.7"
-var vecVersion = "1.0.40"
+var vecVersion = "1.0.41"
 
 repositories {
   exclusiveContent {

libs/simdvec/native/publish_vec_binaries.sh

@@ -20,7 +20,7 @@ if [ -z "$ARTIFACTORY_API_KEY" ]; then
   exit 1;
 fi
 
-VERSION="1.0.40"
+VERSION="1.0.41"
 ARTIFACTORY_REPOSITORY="${ARTIFACTORY_REPOSITORY:-https://artifactory.elastic.dev/artifactory/elasticsearch-native/}"
 TEMP=$(mktemp -d)
 

libs/simdvec/native/src/vec/c/amd64/score_2.cpp

@@ -105,7 +105,7 @@ EXPORT f32_t diskbbq_apply_corrections_maximum_inner_product_bulk_2(
             _mm512_set1_ps(queryAdditionalCorrection - centroidDp)
         );
 
-        __mmask16 is_neg_mask = _mm512_fpclass_ps_mask(res, 0x40);
+        __mmask16 is_neg_mask = _mm512_fpclass_ps_mask(res, 0x50);
         __m512 negative_scaled = _mm512_rcp14_ps(_mm512_fnmadd_ps(_mm512_set1_ps(1.0f), res, _mm512_set1_ps(1.0f)));
         __m512 positive_scaled = _mm512_add_ps(_mm512_set1_ps(1.0f), res);
 

libs/simdvec/src/test/java/org/elasticsearch/simdvec/internal/vectorization/ESNextOSQVectorsScorerTests.java

@@ -354,6 +354,101 @@ private void doTestScoreBulk(int bulkSize) throws Exception {
         }
     }
 
+    /**
+     * Regression test: verifies that the vectorized scorer correctly handles -Infinity raw scores
+     * for MAXIMUM_INNER_PRODUCT. Passing Float.NEGATIVE_INFINITY as queryAdditionalCorrection
+     * (with all-zero corrections) forces every element's raw score to -Infinity before
+     * scaleMaxInnerProductScore is applied. The correct result is 0.0 for all elements.
+     *
+     * This catches the AVX-512 bug where {@code _mm512_fpclass_ps_mask(res, 0x40)} (Negative Finite)
+     * failed to classify -Infinity as negative, causing the positive branch ({@code 1 + res = -Infinity})
+     * to be used instead of the negative branch ({@code 1/(1 - res) = 0}).
+     */
+    public void testScoreBulkWithNegativeInfinityScore() throws Exception {
+        final int dimensions = 768;
+        final int bulkSize = ESNextOSQVectorsScorer.BULK_SIZE;
+
+        final int length = switch (indexBits) {
+            case 1 -> ESNextDiskBBQVectorsFormat.QuantEncoding.ONE_BIT_4BIT_QUERY.getDocPackedLength(dimensions);
+            case 2 -> ESNextDiskBBQVectorsFormat.QuantEncoding.TWO_BIT_4BIT_QUERY.getDocPackedLength(dimensions);
+            case 4 -> ESNextDiskBBQVectorsFormat.QuantEncoding.FOUR_BIT_SYMMETRIC.getDocPackedLength(dimensions);
+            default -> throw new IllegalArgumentException("Unsupported bits: " + indexBits);
+        };
+        final int queryBytes = length * (queryBits / indexBits);
+
+        try (Directory dir = newParametrizedDirectory()) {
+            try (IndexOutput out = dir.createOutput("testNegInf.bin", IOContext.DEFAULT)) {
+                byte[] vector = new byte[length];
+                for (int i = 0; i < bulkSize; i++) {
+                    random().nextBytes(vector);
+                    out.writeBytes(vector, 0, length);
+                }
+                // All-zero corrections: zero bytes are interpreted identically regardless of byte order
+                byte[] zeroCorrections = new byte[16 * bulkSize];
+                out.writeBytes(zeroCorrections, 0, zeroCorrections.length);
+                CodecUtil.writeFooter(out);
+            }
+
+            byte[] query = new byte[queryBytes];
+            random().nextBytes(query);
+
+            float[] scoresDefault = new float[bulkSize];
+            float[] scoresPanama = new float[bulkSize];
+
+            try (IndexInput in = dir.openInput("testNegInf.bin", IOContext.DEFAULT)) {
+                final long dataLength = (long) bulkSize * length + 16L * bulkSize;
+                final IndexInput slice = in.slice("test", 0, dataLength);
+                final var defaultScorer = defaultProvider().newESNextOSQVectorsScorer(
+                    slice,
+                    queryBits,
+                    indexBits,
+                    dimensions,
+                    length,
+                    bulkSize
+                );
+                final var panamaScorer = maybePanamaProvider().newESNextOSQVectorsScorer(
+                    in,
+                    queryBits,
+                    indexBits,
+                    dimensions,
+                    length,
+                    bulkSize
+                );
+
+                // Pass Float.NEGATIVE_INFINITY as queryAdditionalCorrection.
+                // With all-zero corrections and zero query intervals, the base score is zero,
+                // and adding -Infinity makes every element's total raw score -Infinity.
+                float defaultMaxScore = defaultScorer.scoreBulk(
+                    query,
+                    0f,
+                    0f,
+                    0,
+                    Float.NEGATIVE_INFINITY,
+                    similarityFunction,
+                    0f,
+                    scoresDefault
+                );
+                float panamaMaxScore = panamaScorer.scoreBulk(
+                    query,
+                    0f,
+                    0f,
+                    0,
+                    Float.NEGATIVE_INFINITY,
+                    similarityFunction,
+                    0f,
+                    scoresPanama
+                );
+
+                assertEquals(defaultMaxScore, panamaMaxScore, 1e-2f);
+                for (int j = 0; j < bulkSize; j++) {
+                    assertEquals("score mismatch at index " + j, scoresDefault[j], scoresPanama[j], 1e-2f);
+                }
+                assertEquals(dataLength, slice.getFilePointer());
+                assertEquals(dataLength, in.getFilePointer());
+            }
+        }
+    }
+
     private static void writeCorrections(OptimizedScalarQuantizer.QuantizationResult[] corrections, IndexOutput out) throws IOException {
         for (OptimizedScalarQuantizer.QuantizationResult correction : corrections) {
             out.writeInt(Float.floatToIntBits(correction.lowerInterval()));

muted-tests.yml

@@ -344,9 +344,6 @@ tests:
 - class: org.elasticsearch.xpack.ml.integration.ClassificationIT
   method: testWithOnlyTrainingRowsAndTrainingPercentIsFifty_DependentVariableIsKeyword
   issue: https://github.com/elastic/elasticsearch/issues/142282
-- class: org.elasticsearch.benchmark.vector.scorer.VectorScorerOSQBenchmarkTests
-  method: testBulkScalarVsVectorized {p0=1024 p1=2 p2=MMAP p3=MAXIMUM_INNER_PRODUCT}
-  issue: https://github.com/elastic/elasticsearch/issues/142289
 - class: org.elasticsearch.xpack.analytics.cumulativecardinality.CumulativeCardinalityAggregatorTests
   method: testSimple
   issue: https://github.com/elastic/elasticsearch/issues/142408