Apache Lucene open-source search software
Extract the hnsw graph merging from being part of the vector writer (#12657)
Benjamin Trentea272d0eda14
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex 58b42561f61..96ca2f99df3 100644--- a/lucene/CHANGES.txt+++ b/lucene/CHANGES.txt@@ -226,7 +226,8 @@ BuildOther----------------------(No changes)++* GITHUB#12657: Internal refactor of HNSW graph merging (Ben Trent).======================== Lucene 9.8.0 =======================diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswVectorsWriter.java b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswVectorsWriter.javaindex 9281b637441..22234c3f9ec 100644--- a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswVectorsWriter.java+++ b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswVectorsWriter.java@@ -25,7 +25,6 @@ import java.nio.ByteOrder;import java.util.Arrays;import org.apache.lucene.codecs.BufferingKnnVectorsWriter;import org.apache.lucene.codecs.CodecUtil;-import org.apache.lucene.codecs.lucene95.Lucene95HnswVectorsWriter;import org.apache.lucene.index.ByteVectorValues;import org.apache.lucene.index.DocsWithFieldSet;import org.apache.lucene.index.FieldInfo;@@ -37,6 +36,7 @@ import org.apache.lucene.search.DocIdSetIterator;import org.apache.lucene.store.IndexInput;import org.apache.lucene.store.IndexOutput;import org.apache.lucene.util.IOUtils;+import org.apache.lucene.util.hnsw.HnswGraph;import org.apache.lucene.util.hnsw.RandomAccessVectorValues;/**@@ -227,7 +227,7 @@ public final class Lucene91HnswVectorsWriter extends BufferingKnnVectorsWriter {} else {meta.writeInt(graph.numLevels());for (int level = 0; level < graph.numLevels(); level++) {- int[] sortedNodes = Lucene95HnswVectorsWriter.getSortedNodes(graph.getNodesOnLevel(level));+ int[] sortedNodes = HnswGraph.NodesIterator.getSortedNodes(graph.getNodesOnLevel(level));meta.writeInt(sortedNodes.length); // number of nodes on a levelif (level > 0) {for (int node : sortedNodes) {@@ -256,7 +256,7 @@ public final class Lucene91HnswVectorsWriter extends BufferingKnnVectorsWriter {// write vectors' neighbours on each level into the vectorIndex fileint countOnLevel0 = graph.size();for (int level = 0; level < graph.numLevels(); level++) {- int[] sortedNodes = Lucene95HnswVectorsWriter.getSortedNodes(graph.getNodesOnLevel(level));+ int[] sortedNodes = HnswGraph.NodesIterator.getSortedNodes(graph.getNodesOnLevel(level));for (int node : sortedNodes) {Lucene91NeighborArray neighbors = graph.getNeighbors(level, node);int size = neighbors.size();diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene92/Lucene92HnswVectorsWriter.java b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene92/Lucene92HnswVectorsWriter.javaindex 0794c101cac..3194f1090d7 100644--- a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene92/Lucene92HnswVectorsWriter.java+++ b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene92/Lucene92HnswVectorsWriter.java@@ -27,7 +27,6 @@ import java.util.Arrays;import org.apache.lucene.codecs.BufferingKnnVectorsWriter;import org.apache.lucene.codecs.CodecUtil;import org.apache.lucene.codecs.lucene90.IndexedDISI;-import org.apache.lucene.codecs.lucene95.Lucene95HnswVectorsWriter;import org.apache.lucene.index.ByteVectorValues;import org.apache.lucene.index.DocsWithFieldSet;import org.apache.lucene.index.FieldInfo;@@ -39,6 +38,7 @@ import org.apache.lucene.search.DocIdSetIterator;import org.apache.lucene.store.IndexInput;import org.apache.lucene.store.IndexOutput;import org.apache.lucene.util.IOUtils;+import org.apache.lucene.util.hnsw.HnswGraph;import org.apache.lucene.util.hnsw.HnswGraphBuilder;import org.apache.lucene.util.hnsw.NeighborArray;import org.apache.lucene.util.hnsw.OnHeapHnswGraph;@@ -261,7 +261,7 @@ public final class Lucene92HnswVectorsWriter extends BufferingKnnVectorsWriter {} else {meta.writeInt(graph.numLevels());for (int level = 0; level < graph.numLevels(); level++) {- int[] sortedNodes = Lucene95HnswVectorsWriter.getSortedNodes(graph.getNodesOnLevel(level));+ int[] sortedNodes = HnswGraph.NodesIterator.getSortedNodes(graph.getNodesOnLevel(level));meta.writeInt(sortedNodes.length); // number of nodes on a levelif (level > 0) {for (int node : sortedNodes) {@@ -289,7 +289,7 @@ public final class Lucene92HnswVectorsWriter extends BufferingKnnVectorsWriter {int countOnLevel0 = graph.size();for (int level = 0; level < graph.numLevels(); level++) {int maxConnOnLevel = level == 0 ? (M * 2) : M;- int[] sortedNodes = Lucene95HnswVectorsWriter.getSortedNodes(graph.getNodesOnLevel(level));+ int[] sortedNodes = HnswGraph.NodesIterator.getSortedNodes(graph.getNodesOnLevel(level));for (int node : sortedNodes) {NeighborArray neighbors = graph.getNeighbors(level, node);int size = neighbors.size();diff --git a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene94/Lucene94HnswVectorsWriter.java b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene94/Lucene94HnswVectorsWriter.javaindex ecbe879a912..8c23dd0234b 100644--- a/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene94/Lucene94HnswVectorsWriter.java+++ b/lucene/backward-codecs/src/test/org/apache/lucene/backward_codecs/lucene94/Lucene94HnswVectorsWriter.java@@ -30,7 +30,6 @@ import org.apache.lucene.codecs.CodecUtil;import org.apache.lucene.codecs.KnnFieldVectorsWriter;import org.apache.lucene.codecs.KnnVectorsWriter;import org.apache.lucene.codecs.lucene90.IndexedDISI;-import org.apache.lucene.codecs.lucene95.Lucene95HnswVectorsWriter;import org.apache.lucene.index.ByteVectorValues;import org.apache.lucene.index.DocsWithFieldSet;import org.apache.lucene.index.FieldInfo;@@ -477,7 +476,7 @@ public final class Lucene94HnswVectorsWriter extends KnnVectorsWriter {int countOnLevel0 = graph.size();for (int level = 0; level < graph.numLevels(); level++) {int maxConnOnLevel = level == 0 ? (M * 2) : M;- int[] sortedNodes = Lucene95HnswVectorsWriter.getSortedNodes(graph.getNodesOnLevel(level));+ int[] sortedNodes = HnswGraph.NodesIterator.getSortedNodes(graph.getNodesOnLevel(level));for (int node : sortedNodes) {NeighborArray neighbors = graph.getNeighbors(level, node);int size = neighbors.size();@@ -565,7 +564,7 @@ public final class Lucene94HnswVectorsWriter extends KnnVectorsWriter {} else {meta.writeInt(graph.numLevels());for (int level = 0; level < graph.numLevels(); level++) {- int[] sortedNodes = Lucene95HnswVectorsWriter.getSortedNodes(graph.getNodesOnLevel(level));+ int[] sortedNodes = HnswGraph.NodesIterator.getSortedNodes(graph.getNodesOnLevel(level));meta.writeInt(sortedNodes.length); // number of nodes on a levelif (level > 0) {for (int node : sortedNodes) {diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene95/Lucene95HnswVectorsWriter.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene95/Lucene95HnswVectorsWriter.javaindex 10bef300c2c..8397b503197 100644--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene95/Lucene95HnswVectorsWriter.java+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene95/Lucene95HnswVectorsWriter.java@@ -25,16 +25,10 @@ import java.nio.ByteBuffer;import java.nio.ByteOrder;import java.util.ArrayList;import java.util.Arrays;-import java.util.Collections;-import java.util.HashMap;import java.util.List;-import java.util.Map;import org.apache.lucene.codecs.CodecUtil;-import org.apache.lucene.codecs.HnswGraphProvider;import org.apache.lucene.codecs.KnnFieldVectorsWriter;-import org.apache.lucene.codecs.KnnVectorsReader;import org.apache.lucene.codecs.KnnVectorsWriter;-import org.apache.lucene.codecs.perfield.PerFieldKnnVectorsFormat;import org.apache.lucene.index.*;import org.apache.lucene.index.Sorter;import org.apache.lucene.search.DocIdSetIterator;@@ -423,51 +417,49 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {OnHeapHnswGraph graph = null;int[][] vectorIndexNodeOffsets = null;if (docsWithField.cardinality() != 0) {- // build graph- int initializerIndex = selectGraphForInitialization(mergeState, fieldInfo);- graph =- switch (fieldInfo.getVectorEncoding()) {- case BYTE -> {- OffHeapByteVectorValues.DenseOffHeapVectorValues vectorValues =+ final RandomVectorScorerSupplier scorerSupplier;+ switch (fieldInfo.getVectorEncoding()) {+ case BYTE:+ scorerSupplier =+ RandomVectorScorerSupplier.createBytes(new OffHeapByteVectorValues.DenseOffHeapVectorValues(fieldInfo.getVectorDimension(),docsWithField.cardinality(),vectorDataInput,- byteSize);- RandomVectorScorerSupplier scorerSupplier =- RandomVectorScorerSupplier.createBytes(- vectorValues, fieldInfo.getVectorSimilarityFunction());- HnswGraphBuilder hnswGraphBuilder =- createHnswGraphBuilder(- mergeState,- fieldInfo,- scorerSupplier,- initializerIndex,- vectorValues.size());- hnswGraphBuilder.setInfoStream(segmentWriteState.infoStream);- yield hnswGraphBuilder.build(vectorValues.size());- }- case FLOAT32 -> {- OffHeapFloatVectorValues.DenseOffHeapVectorValues vectorValues =+ byteSize),+ fieldInfo.getVectorSimilarityFunction());+ break;+ case FLOAT32:+ scorerSupplier =+ RandomVectorScorerSupplier.createFloats(new OffHeapFloatVectorValues.DenseOffHeapVectorValues(fieldInfo.getVectorDimension(),docsWithField.cardinality(),vectorDataInput,- byteSize);- RandomVectorScorerSupplier scorerSupplier =- RandomVectorScorerSupplier.createFloats(- vectorValues, fieldInfo.getVectorSimilarityFunction());- HnswGraphBuilder hnswGraphBuilder =- createHnswGraphBuilder(- mergeState,- fieldInfo,- scorerSupplier,- initializerIndex,- vectorValues.size());- hnswGraphBuilder.setInfoStream(segmentWriteState.infoStream);- yield hnswGraphBuilder.build(vectorValues.size());- }- };+ byteSize),+ fieldInfo.getVectorSimilarityFunction());+ break;+ default:+ throw new IllegalArgumentException(+ "Unsupported vector encoding: " + fieldInfo.getVectorEncoding());+ }+ // build graph+ IncrementalHnswGraphMerger merger =+ new IncrementalHnswGraphMerger(fieldInfo, scorerSupplier, M, beamWidth);+ for (int i = 0; i < mergeState.liveDocs.length; i++) {+ merger.addReader(+ mergeState.knnVectorsReaders[i], mergeState.docMaps[i], mergeState.liveDocs[i]);+ }+ DocIdSetIterator mergedVectorIterator = null;+ switch (fieldInfo.getVectorEncoding()) {+ case BYTE -> mergedVectorIterator =+ KnnVectorsWriter.MergedVectorValues.mergeByteVectorValues(fieldInfo, mergeState);+ case FLOAT32 -> mergedVectorIterator =+ KnnVectorsWriter.MergedVectorValues.mergeFloatVectorValues(fieldInfo, mergeState);+ }+ HnswGraphBuilder hnswGraphBuilder = merger.createBuilder(mergedVectorIterator);+ hnswGraphBuilder.setInfoStream(segmentWriteState.infoStream);+ graph = hnswGraphBuilder.build(docsWithField.cardinality());vectorIndexNodeOffsets = writeGraph(graph);}long vectorIndexLength = vectorIndex.getFilePointer() - vectorIndexOffset;@@ -494,185 +486,6 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {}}- private HnswGraphBuilder createHnswGraphBuilder(- MergeState mergeState,- FieldInfo fieldInfo,- RandomVectorScorerSupplier scorerSupplier,- int initializerIndex,- int graphSize)- throws IOException {- if (initializerIndex == -1) {- return HnswGraphBuilder.create(- scorerSupplier, M, beamWidth, HnswGraphBuilder.randSeed, graphSize);- }-- HnswGraph initializerGraph =- getHnswGraphFromReader(fieldInfo.name, mergeState.knnVectorsReaders[initializerIndex]);- Map<Integer, Integer> ordinalMapper =- getOldToNewOrdinalMap(mergeState, fieldInfo, initializerIndex);- return HnswGraphBuilder.create(- scorerSupplier,- M,- beamWidth,- HnswGraphBuilder.randSeed,- initializerGraph,- ordinalMapper,- graphSize);- }-- private int selectGraphForInitialization(MergeState mergeState, FieldInfo fieldInfo)- throws IOException {- // Find the KnnVectorReader with the most docs that meets the following criteria:- // 1. Does not contain any deleted docs- // 2. Is a HnswGraphProvider/PerFieldKnnVectorReader- // If no readers exist that meet this criteria, return -1. If they do, return their index in- // merge state- int maxCandidateVectorCount = 0;- int initializerIndex = -1;-- for (int i = 0; i < mergeState.liveDocs.length; i++) {- KnnVectorsReader currKnnVectorsReader = mergeState.knnVectorsReaders[i];- if (mergeState.knnVectorsReaders[i]- instanceof PerFieldKnnVectorsFormat.FieldsReader candidateReader) {- currKnnVectorsReader = candidateReader.getFieldReader(fieldInfo.name);- }-- if (!allMatch(mergeState.liveDocs[i])- || !(currKnnVectorsReader instanceof HnswGraphProvider)) {- continue;- }-- int candidateVectorCount = 0;- switch (fieldInfo.getVectorEncoding()) {- case BYTE -> {- ByteVectorValues byteVectorValues =- currKnnVectorsReader.getByteVectorValues(fieldInfo.name);- if (byteVectorValues == null) {- continue;- }- candidateVectorCount = byteVectorValues.size();- }- case FLOAT32 -> {- FloatVectorValues vectorValues =- currKnnVectorsReader.getFloatVectorValues(fieldInfo.name);- if (vectorValues == null) {- continue;- }- candidateVectorCount = vectorValues.size();- }- }-- if (candidateVectorCount > maxCandidateVectorCount) {- maxCandidateVectorCount = candidateVectorCount;- initializerIndex = i;- }- }- return initializerIndex;- }-- private HnswGraph getHnswGraphFromReader(String fieldName, KnnVectorsReader knnVectorsReader)- throws IOException {- if (knnVectorsReader instanceof PerFieldKnnVectorsFormat.FieldsReader perFieldReader- && perFieldReader.getFieldReader(fieldName) instanceof HnswGraphProvider fieldReader) {- return fieldReader.getGraph(fieldName);- }-- if (knnVectorsReader instanceof HnswGraphProvider provider) {- return provider.getGraph(fieldName);- }-- // We should not reach here because knnVectorsReader's type is checked in- // selectGraphForInitialization- throw new IllegalArgumentException(- "Invalid KnnVectorsReader type for field: "- + fieldName- + ". Must be Lucene95HnswVectorsReader or newer");- }-- private Map<Integer, Integer> getOldToNewOrdinalMap(- MergeState mergeState, FieldInfo fieldInfo, int initializerIndex) throws IOException {-- DocIdSetIterator initializerIterator = null;-- switch (fieldInfo.getVectorEncoding()) {- case BYTE -> initializerIterator =- mergeState.knnVectorsReaders[initializerIndex].getByteVectorValues(fieldInfo.name);- case FLOAT32 -> initializerIterator =- mergeState.knnVectorsReaders[initializerIndex].getFloatVectorValues(fieldInfo.name);- }-- MergeState.DocMap initializerDocMap = mergeState.docMaps[initializerIndex];-- Map<Integer, Integer> newIdToOldOrdinal = new HashMap<>();- int oldOrd = 0;- int maxNewDocID = -1;- for (int oldId = initializerIterator.nextDoc();- oldId != NO_MORE_DOCS;- oldId = initializerIterator.nextDoc()) {- if (isCurrentVectorNull(initializerIterator)) {- continue;- }- int newId = initializerDocMap.get(oldId);- maxNewDocID = Math.max(newId, maxNewDocID);- newIdToOldOrdinal.put(newId, oldOrd);- oldOrd++;- }-- if (maxNewDocID == -1) {- return Collections.emptyMap();- }-- Map<Integer, Integer> oldToNewOrdinalMap = new HashMap<>();-- DocIdSetIterator vectorIterator = null;- switch (fieldInfo.getVectorEncoding()) {- case BYTE -> vectorIterator = MergedVectorValues.mergeByteVectorValues(fieldInfo, mergeState);- case FLOAT32 -> vectorIterator =- MergedVectorValues.mergeFloatVectorValues(fieldInfo, mergeState);- }-- int newOrd = 0;- for (int newDocId = vectorIterator.nextDoc();- newDocId <= maxNewDocID;- newDocId = vectorIterator.nextDoc()) {- if (isCurrentVectorNull(vectorIterator)) {- continue;- }-- if (newIdToOldOrdinal.containsKey(newDocId)) {- oldToNewOrdinalMap.put(newIdToOldOrdinal.get(newDocId), newOrd);- }- newOrd++;- }-- return oldToNewOrdinalMap;- }-- private boolean isCurrentVectorNull(DocIdSetIterator docIdSetIterator) throws IOException {- if (docIdSetIterator instanceof FloatVectorValues) {- return ((FloatVectorValues) docIdSetIterator).vectorValue() == null;- }-- if (docIdSetIterator instanceof ByteVectorValues) {- return ((ByteVectorValues) docIdSetIterator).vectorValue() == null;- }-- return true;- }-- private boolean allMatch(Bits bits) {- if (bits == null) {- return true;- }-- for (int i = 0; i < bits.length(); i++) {- if (!bits.get(i)) {- return false;- }- }- return true;- }-/*** @param graph Write the graph in a compressed format* @return The non-cumulative offsets for the nodes. Should be used to create cumulative offsets.@@ -684,7 +497,7 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {int countOnLevel0 = graph.size();int[][] offsets = new int[graph.numLevels()][];for (int level = 0; level < graph.numLevels(); level++) {- int[] sortedNodes = getSortedNodes(graph.getNodesOnLevel(level));+ int[] sortedNodes = HnswGraph.NodesIterator.getSortedNodes(graph.getNodesOnLevel(level));offsets[level] = new int[sortedNodes.length];int nodeOffsetId = 0;for (int node : sortedNodes) {@@ -712,15 +525,6 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {return offsets;}- public static int[] getSortedNodes(NodesIterator nodesOnLevel) {- int[] sortedNodes = new int[nodesOnLevel.size()];- for (int n = 0; nodesOnLevel.hasNext(); n++) {- sortedNodes[n] = nodesOnLevel.nextInt();- }- Arrays.sort(sortedNodes);- return sortedNodes;- }-private void writeMeta(FieldInfo field,int maxDoc,diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraph.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraph.javaindex 54ff49f0602..85d14c0096d 100644--- a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraph.java+++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraph.java@@ -20,6 +20,7 @@ package org.apache.lucene.util.hnsw;import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;import java.io.IOException;+import java.util.Arrays;import java.util.Collection;import java.util.Iterator;import java.util.NoSuchElementException;@@ -152,6 +153,15 @@ public abstract class HnswGraph {* @return The number of integers written to `dest`*/public abstract int consume(int[] dest);++ public static int[] getSortedNodes(NodesIterator nodesOnLevel) {+ int[] sortedNodes = new int[nodesOnLevel.size()];+ for (int n = 0; nodesOnLevel.hasNext(); n++) {+ sortedNodes[n] = nodesOnLevel.nextInt();+ }+ Arrays.sort(sortedNodes);+ return sortedNodes;+ }}/** NodesIterator that accepts nodes as an integer array. */diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphBuilder.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphBuilder.javaindex 48e6cd219d3..d1f8c3d8045 100644--- a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphBuilder.java+++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphBuilder.java@@ -18,14 +18,10 @@package org.apache.lucene.util.hnsw;import static java.lang.Math.log;-import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;import java.io.IOException;-import java.util.HashSet;import java.util.Locale;-import java.util.Map;import java.util.Objects;-import java.util.Set;import java.util.SplittableRandom;import java.util.concurrent.TimeUnit;import org.apache.lucene.search.KnnCollector;@@ -37,7 +33,7 @@ import org.apache.lucene.util.InfoStream;* Builder for HNSW graph. See {@link HnswGraph} for a gloss on the algorithm and the meaning of the* hyper-parameters.*/-public final class HnswGraphBuilder {+public class HnswGraphBuilder {/** Default number of maximum connections per node */public static final int DEFAULT_MAX_CONN = 16;@@ -67,12 +63,10 @@ public final class HnswGraphBuilder {private final GraphBuilderKnnCollectorbeamCandidates; // for levels of graph where we add the node- final OnHeapHnswGraph hnsw;+ protected final OnHeapHnswGraph hnsw;private InfoStream infoStream = InfoStream.getDefault();- private final Set<Integer> initializedNodes;-public static HnswGraphBuilder create(RandomVectorScorerSupplier scorerSupplier, int M, int beamWidth, long seed)throws IOException {@@ -80,23 +74,27 @@ public final class HnswGraphBuilder {}public static HnswGraphBuilder create(- RandomVectorScorerSupplier scorerSupplier, int M, int beamWidth, long seed, int graphSize) {+ RandomVectorScorerSupplier scorerSupplier, int M, int beamWidth, long seed, int graphSize)+ throws IOException {return new HnswGraphBuilder(scorerSupplier, M, beamWidth, seed, graphSize);}- public static HnswGraphBuilder create(- RandomVectorScorerSupplier scorerSupplier,- int M,- int beamWidth,- long seed,- HnswGraph initializerGraph,- Map<Integer, Integer> oldToNewOrdinalMap,- int graphSize)+ /**+ * Reads all the vectors from vector values, builds a graph connecting them by their dense+ * ordinals, using the given hyperparameter settings, and returns the resulting graph.+ *+ * @param scorerSupplier a supplier to create vector scorer from ordinals.+ * @param M – graph fanout parameter used to calculate the maximum number of connections a node+ * can have – M on upper layers, and M * 2 on the lowest level.+ * @param beamWidth the size of the beam search to use when finding nearest neighbors.+ * @param seed the seed for a random number generator used during graph construction. Provide this+ * to ensure repeatable construction.+ * @param graphSize size of graph, if unknown, pass in -1+ */+ protected HnswGraphBuilder(+ RandomVectorScorerSupplier scorerSupplier, int M, int beamWidth, long seed, int graphSize)throws IOException {- HnswGraphBuilder hnswGraphBuilder =- new HnswGraphBuilder(scorerSupplier, M, beamWidth, seed, graphSize);- hnswGraphBuilder.initializeFromGraph(initializerGraph, oldToNewOrdinalMap);- return hnswGraphBuilder;+ this(scorerSupplier, M, beamWidth, seed, new OnHeapHnswGraph(M, graphSize));}/**@@ -109,10 +107,15 @@ public final class HnswGraphBuilder {* @param beamWidth the size of the beam search to use when finding nearest neighbors.* @param seed the seed for a random number generator used during graph construction. Provide this* to ensure repeatable construction.- * @param graphSize size of graph, if unknown, pass in -1+ * @param hnsw the graph to build, can be previously initialized*/- private HnswGraphBuilder(- RandomVectorScorerSupplier scorerSupplier, int M, int beamWidth, long seed, int graphSize) {+ protected HnswGraphBuilder(+ RandomVectorScorerSupplier scorerSupplier,+ int M,+ int beamWidth,+ long seed,+ OnHeapHnswGraph hnsw)+ throws IOException {if (M <= 0) {throw new IllegalArgumentException("maxConn must be positive");}@@ -125,7 +128,7 @@ public final class HnswGraphBuilder {// normalization factor for level generation; currently not configurablethis.ml = M == 1 ? 1 : 1 / Math.log(1.0 * M);this.random = new SplittableRandom(seed);- this.hnsw = new OnHeapHnswGraph(M, graphSize);+ this.hnsw = hnsw;this.graphSearcher =new HnswGraphSearcher(new NeighborQueue(beamWidth, true), new FixedBitSet(this.getGraph().size()));@@ -133,7 +136,6 @@ public final class HnswGraphBuilder {scratch = new NeighborArray(Math.max(beamWidth, M + 1), false);entryCandidates = new GraphBuilderKnnCollector(1);beamCandidates = new GraphBuilderKnnCollector(beamWidth);- this.initializedNodes = new HashSet<>();}/**@@ -149,45 +151,6 @@ public final class HnswGraphBuilder {return hnsw;}- /**- * Initializes the graph of this builder. Transfers the nodes and their neighbors from the- * initializer graph into the graph being produced by this builder, mapping ordinals from the- * initializer graph to their new ordinals in this builder's graph. The builder's graph must be- * empty before calling this method.- *- * @param initializerGraph graph used for initialization- * @param oldToNewOrdinalMap map for converting from ordinals in the initializerGraph to this- * builder's graph- */- private void initializeFromGraph(- HnswGraph initializerGraph, Map<Integer, Integer> oldToNewOrdinalMap) throws IOException {- assert hnsw.size() == 0;- for (int level = initializerGraph.numLevels() - 1; level >= 0; level--) {- HnswGraph.NodesIterator it = initializerGraph.getNodesOnLevel(level);-- while (it.hasNext()) {- int oldOrd = it.nextInt();- int newOrd = oldToNewOrdinalMap.get(oldOrd);-- hnsw.addNode(level, newOrd);-- if (level == 0) {- initializedNodes.add(newOrd);- }-- NeighborArray newNeighbors = this.hnsw.getNeighbors(level, newOrd);- initializerGraph.seek(level, oldOrd);- for (int oldNeighbor = initializerGraph.nextNeighbor();- oldNeighbor != NO_MORE_DOCS;- oldNeighbor = initializerGraph.nextNeighbor()) {- int newNeighbor = oldToNewOrdinalMap.get(oldNeighbor);- // we will compute these scores later when we need to pop out the non-diverse nodes- newNeighbors.addOutOfOrder(newNeighbor, Float.NaN);- }- }- }- }-/** Set info-stream to output debugging information * */public void setInfoStream(InfoStream infoStream) {this.infoStream = infoStream;@@ -200,9 +163,6 @@ public final class HnswGraphBuilder {private void addVectors(int maxOrd) throws IOException {long start = System.nanoTime(), t = start;for (int node = 0; node < maxOrd; node++) {- if (initializedNodes.contains(node)) {- continue;- }addGraphNode(node);if ((node % 10000 == 0) && infoStream.isEnabled(HNSW_COMPONENT)) {t = printGraphBuildStatus(node, start, t);diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/IncrementalHnswGraphMerger.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/IncrementalHnswGraphMerger.javanew file mode 100644index 00000000000..5ddb23990e1--- /dev/null+++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/IncrementalHnswGraphMerger.java@@ -0,0 +1,199 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You under the Apache License, Version 2.0+ * (the "License"); you may not use this file except in compliance with+ * the License. You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package org.apache.lucene.util.hnsw;++import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;++import java.io.IOException;+import java.util.Map;+import org.apache.lucene.codecs.HnswGraphProvider;+import org.apache.lucene.codecs.KnnVectorsReader;+import org.apache.lucene.codecs.perfield.PerFieldKnnVectorsFormat;+import org.apache.lucene.index.ByteVectorValues;+import org.apache.lucene.index.FieldInfo;+import org.apache.lucene.index.FloatVectorValues;+import org.apache.lucene.index.MergeState;+import org.apache.lucene.search.DocIdSetIterator;+import org.apache.lucene.util.BitSet;+import org.apache.lucene.util.Bits;+import org.apache.lucene.util.CollectionUtil;+import org.apache.lucene.util.FixedBitSet;++/**+ * This selects the biggest Hnsw graph from the provided merge state and initializes a new+ * HnswGraphBuilder with that graph as a starting point.+ *+ * @lucene.experimental+ */+public class IncrementalHnswGraphMerger {++ private KnnVectorsReader initReader;+ private MergeState.DocMap initDocMap;+ private int initGraphSize;+ private final FieldInfo fieldInfo;+ private final RandomVectorScorerSupplier scorerSupplier;+ private final int M;+ private final int beamWidth;++ /**+ * @param fieldInfo FieldInfo for the field being merged+ */+ public IncrementalHnswGraphMerger(+ FieldInfo fieldInfo, RandomVectorScorerSupplier scorerSupplier, int M, int beamWidth) {+ this.fieldInfo = fieldInfo;+ this.scorerSupplier = scorerSupplier;+ this.M = M;+ this.beamWidth = beamWidth;+ }++ /**+ * Adds a reader to the graph merger if it meets the following criteria: 1. Does not contain any+ * deleted docs 2. Is a HnswGraphProvider/PerFieldKnnVectorReader 3. Has the most docs of any+ * previous reader that met the above criteria+ *+ * @param reader KnnVectorsReader to add to the merger+ * @param docMap MergeState.DocMap for the reader+ * @param liveDocs Bits representing live docs, can be null+ * @return this+ * @throws IOException If an error occurs while reading from the merge state+ */+ public IncrementalHnswGraphMerger addReader(+ KnnVectorsReader reader, MergeState.DocMap docMap, Bits liveDocs) throws IOException {+ KnnVectorsReader currKnnVectorsReader = reader;+ if (reader instanceof PerFieldKnnVectorsFormat.FieldsReader candidateReader) {+ currKnnVectorsReader = candidateReader.getFieldReader(fieldInfo.name);+ }++ if (!(currKnnVectorsReader instanceof HnswGraphProvider) || !noDeletes(liveDocs)) {+ return this;+ }++ int candidateVectorCount = 0;+ switch (fieldInfo.getVectorEncoding()) {+ case BYTE -> {+ ByteVectorValues byteVectorValues =+ currKnnVectorsReader.getByteVectorValues(fieldInfo.name);+ if (byteVectorValues == null) {+ return this;+ }+ candidateVectorCount = byteVectorValues.size();+ }+ case FLOAT32 -> {+ FloatVectorValues vectorValues = currKnnVectorsReader.getFloatVectorValues(fieldInfo.name);+ if (vectorValues == null) {+ return this;+ }+ candidateVectorCount = vectorValues.size();+ }+ }+ if (candidateVectorCount > initGraphSize) {+ initReader = currKnnVectorsReader;+ initDocMap = docMap;+ initGraphSize = candidateVectorCount;+ }+ return this;+ }++ /**+ * Builds a new HnswGraphBuilder using the biggest graph from the merge state as a starting point.+ * If no valid readers were added to the merge state, a new graph is created.+ *+ * @param mergedVectorIterator iterator over the vectors in the merged segment+ * @return HnswGraphBuilder+ * @throws IOException If an error occurs while reading from the merge state+ */+ public HnswGraphBuilder createBuilder(DocIdSetIterator mergedVectorIterator) throws IOException {+ if (initReader == null) {+ return HnswGraphBuilder.create(scorerSupplier, M, beamWidth, HnswGraphBuilder.randSeed);+ }++ HnswGraph initializerGraph = ((HnswGraphProvider) initReader).getGraph(fieldInfo.name);+ final int numVectors = Math.toIntExact(mergedVectorIterator.cost());++ BitSet initializedNodes = new FixedBitSet(numVectors + 1);+ int[] oldToNewOrdinalMap = getNewOrdMapping(mergedVectorIterator, initializedNodes);+ return InitializedHnswGraphBuilder.fromGraph(+ scorerSupplier,+ M,+ beamWidth,+ HnswGraphBuilder.randSeed,+ initializerGraph,+ oldToNewOrdinalMap,+ initializedNodes,+ numVectors);+ }++ /**+ * Creates a new mapping from old ordinals to new ordinals and returns the total number of vectors+ * in the newly merged segment.+ *+ * @param mergedVectorIterator iterator over the vectors in the merged segment+ * @param initializedNodes track what nodes have been initialized+ * @return the mapping from old ordinals to new ordinals+ * @throws IOException If an error occurs while reading from the merge state+ */+ private int[] getNewOrdMapping(DocIdSetIterator mergedVectorIterator, BitSet initializedNodes)+ throws IOException {+ DocIdSetIterator initializerIterator = null;++ switch (fieldInfo.getVectorEncoding()) {+ case BYTE -> initializerIterator = initReader.getByteVectorValues(fieldInfo.name);+ case FLOAT32 -> initializerIterator = initReader.getFloatVectorValues(fieldInfo.name);+ }++ Map<Integer, Integer> newIdToOldOrdinal = CollectionUtil.newHashMap(initGraphSize);+ int oldOrd = 0;+ int maxNewDocID = -1;+ for (int oldId = initializerIterator.nextDoc();+ oldId != NO_MORE_DOCS;+ oldId = initializerIterator.nextDoc()) {+ int newId = initDocMap.get(oldId);+ maxNewDocID = Math.max(newId, maxNewDocID);+ newIdToOldOrdinal.put(newId, oldOrd);+ oldOrd++;+ }++ if (maxNewDocID == -1) {+ return new int[0];+ }+ final int[] oldToNewOrdinalMap = new int[initGraphSize];+ int newOrd = 0;+ for (int newDocId = mergedVectorIterator.nextDoc();+ newDocId <= maxNewDocID;+ newDocId = mergedVectorIterator.nextDoc()) {+ if (newIdToOldOrdinal.containsKey(newDocId)) {+ initializedNodes.set(newOrd);+ oldToNewOrdinalMap[newIdToOldOrdinal.get(newDocId)] = newOrd;+ }+ newOrd++;+ }+ return oldToNewOrdinalMap;+ }++ private static boolean noDeletes(Bits liveDocs) {+ if (liveDocs == null) {+ return true;+ }++ for (int i = 0; i < liveDocs.length(); i++) {+ if (!liveDocs.get(i)) {+ return false;+ }+ }+ return true;+ }+}diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/InitializedHnswGraphBuilder.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/InitializedHnswGraphBuilder.javanew file mode 100644index 00000000000..025fdfff571--- /dev/null+++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/InitializedHnswGraphBuilder.java@@ -0,0 +1,101 @@+/*+ * Licensed to the Apache Software Foundation (ASF) under one or more+ * contributor license agreements. See the NOTICE file distributed with+ * this work for additional information regarding copyright ownership.+ * The ASF licenses this file to You under the Apache License, Version 2.0+ * (the "License"); you may not use this file except in compliance with+ * the License. You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++package org.apache.lucene.util.hnsw;++import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;++import java.io.IOException;+import org.apache.lucene.util.BitSet;++/**+ * This creates a graph builder that is initialized with the provided HnswGraph. This is useful for+ * merging HnswGraphs from multiple segments.+ *+ * @lucene.experimental+ */+public final class InitializedHnswGraphBuilder extends HnswGraphBuilder {++ /**+ * Create a new HnswGraphBuilder that is initialized with the provided HnswGraph.+ *+ * @param scorerSupplier the scorer to use for vectors+ * @param M the number of connections to keep per node+ * @param beamWidth the number of nodes to explore in the search+ * @param seed the seed for the random number generator+ * @param initializerGraph the graph to initialize the new graph builder+ * @param newOrdMap a mapping from the old node ordinal to the new node ordinal+ * @param initializedNodes a bitset of nodes that are already initialized in the initializerGraph+ * @param totalNumberOfVectors the total number of vectors in the new graph, this should include+ * all vectors expected to be added to the graph in the future+ * @return a new HnswGraphBuilder that is initialized with the provided HnswGraph+ * @throws IOException when reading the graph fails+ */+ public static InitializedHnswGraphBuilder fromGraph(+ RandomVectorScorerSupplier scorerSupplier,+ int M,+ int beamWidth,+ long seed,+ HnswGraph initializerGraph,+ int[] newOrdMap,+ BitSet initializedNodes,+ int totalNumberOfVectors)+ throws IOException {+ OnHeapHnswGraph hnsw = new OnHeapHnswGraph(M, totalNumberOfVectors);+ for (int level = initializerGraph.numLevels() - 1; level >= 0; level--) {+ HnswGraph.NodesIterator it = initializerGraph.getNodesOnLevel(level);+ while (it.hasNext()) {+ int oldOrd = it.nextInt();+ int newOrd = newOrdMap[oldOrd];+ hnsw.addNode(level, newOrd);+ NeighborArray newNeighbors = hnsw.getNeighbors(level, newOrd);+ initializerGraph.seek(level, oldOrd);+ for (int oldNeighbor = initializerGraph.nextNeighbor();+ oldNeighbor != NO_MORE_DOCS;+ oldNeighbor = initializerGraph.nextNeighbor()) {+ int newNeighbor = newOrdMap[oldNeighbor];+ // we will compute these scores later when we need to pop out the non-diverse nodes+ newNeighbors.addOutOfOrder(newNeighbor, Float.NaN);+ }+ }+ }+ return new InitializedHnswGraphBuilder(+ scorerSupplier, M, beamWidth, seed, hnsw, initializedNodes);+ }++ private final BitSet initializedNodes;++ public InitializedHnswGraphBuilder(+ RandomVectorScorerSupplier scorerSupplier,+ int M,+ int beamWidth,+ long seed,+ OnHeapHnswGraph initializedGraph,+ BitSet initializedNodes)+ throws IOException {+ super(scorerSupplier, M, beamWidth, seed, initializedGraph);+ this.initializedNodes = initializedNodes;+ }++ @Override+ public void addGraphNode(int node) throws IOException {+ if (initializedNodes.get(node)) {+ return;+ }+ super.addGraphNode(node);+ }+}diff --git a/lucene/core/src/test/org/apache/lucene/util/hnsw/HnswGraphTestCase.java b/lucene/core/src/test/org/apache/lucene/util/hnsw/HnswGraphTestCase.javaindex 06f79a2e63a..a18f0d2a2fe 100644--- a/lucene/core/src/test/org/apache/lucene/util/hnsw/HnswGraphTestCase.java+++ b/lucene/core/src/test/org/apache/lucene/util/hnsw/HnswGraphTestCase.java@@ -26,11 +26,9 @@ import java.io.IOException;import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;-import java.util.HashMap;import java.util.HashSet;import java.util.List;import java.util.Locale;-import java.util.Map;import java.util.Random;import java.util.Set;import java.util.concurrent.ExecutionException;@@ -49,6 +47,7 @@ import org.apache.lucene.document.Document;import org.apache.lucene.document.Field;import org.apache.lucene.document.NumericDocValuesField;import org.apache.lucene.document.StoredField;+import org.apache.lucene.document.StringField;import org.apache.lucene.index.ByteVectorValues;import org.apache.lucene.index.CodecReader;import org.apache.lucene.index.DirectoryReader;@@ -59,8 +58,10 @@ import org.apache.lucene.index.IndexWriterConfig;import org.apache.lucene.index.LeafReader;import org.apache.lucene.index.LeafReaderContext;import org.apache.lucene.index.StoredFields;+import org.apache.lucene.index.Term;import org.apache.lucene.index.VectorEncoding;import org.apache.lucene.index.VectorSimilarityFunction;+import org.apache.lucene.search.DocIdSetIterator;import org.apache.lucene.search.IndexSearcher;import org.apache.lucene.search.KnnCollector;import org.apache.lucene.search.Query;@@ -132,6 +133,73 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {};}+ // Tests writing segments of various sizes and merging to ensure there are no errors+ // in the HNSW graph merging logic.+ public void testRandomReadWriteAndMerge() throws IOException {+ int dim = random().nextInt(100) + 1;+ int[] segmentSizes =+ new int[] {random().nextInt(20) + 1, random().nextInt(10) + 30, random().nextInt(10) + 20};+ // Randomly delete vector documents+ boolean[] addDeletes =+ new boolean[] {random().nextBoolean(), random().nextBoolean(), random().nextBoolean()};+ // randomly index other documents besides vector docs+ boolean[] isSparse =+ new boolean[] {random().nextBoolean(), random().nextBoolean(), random().nextBoolean()};+ int numVectors = segmentSizes[0] + segmentSizes[1] + segmentSizes[2];+ int M = random().nextInt(4) + 2;+ int beamWidth = random().nextInt(10) + 5;+ long seed = random().nextLong();+ AbstractMockVectorValues<T> vectors = vectorValues(numVectors, dim);+ HnswGraphBuilder.randSeed = seed;++ try (Directory dir = newDirectory()) {+ IndexWriterConfig iwc =+ new IndexWriterConfig()+ .setCodec(+ new Lucene95Codec() {+ @Override+ public KnnVectorsFormat getKnnVectorsFormatForField(String field) {+ return new Lucene95HnswVectorsFormat(M, beamWidth);+ }+ })+ // set a random merge policy+ .setMergePolicy(newMergePolicy(random()));+ try (IndexWriter iw = new IndexWriter(dir, iwc)) {+ for (int i = 0; i < segmentSizes.length; i++) {+ int size = segmentSizes[i];+ while (vectors.nextDoc() < size) {+ if (isSparse[i] && random().nextBoolean()) {+ int d = random().nextInt(10) + 1;+ for (int j = 0; j < d; j++) {+ Document doc = new Document();+ iw.addDocument(doc);+ }+ }+ Document doc = new Document();+ doc.add(knnVectorField("field", vectors.vectorValue(), similarityFunction));+ doc.add(new StringField("id", Integer.toString(vectors.docID()), Field.Store.NO));+ iw.addDocument(doc);+ }+ iw.commit();+ if (addDeletes[i] && size > 1) {+ for (int d = 0; d < size; d += random().nextInt(5) + 1) {+ iw.deleteDocuments(new Term("id", Integer.toString(d)));+ }+ iw.commit();+ }+ }+ iw.commit();+ iw.forceMerge(1);+ }+ try (IndexReader reader = DirectoryReader.open(dir)) {+ for (LeafReaderContext ctx : reader.leaves()) {+ AbstractMockVectorValues<T> values = vectorValues(ctx.reader(), "field");+ assertEquals(dim, values.dimension());+ }+ }+ }+ }+// test writing out and reading in a graph gives the expected graphpublic void testReadWrite() throws IOException {int dim = random().nextInt(100) + 1;@@ -469,20 +537,21 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {OnHeapHnswGraph initializerGraph = initializerBuilder.build(initializerVectors.size());AbstractMockVectorValues<T> finalVectorValues =vectorValues(totalSize, dim, initializerVectors, docIdOffset);-- Map<Integer, Integer> initializerOrdMap =+ int[] initializerOrdMap =createOffsetOrdinalMap(initializerSize, finalVectorValues, docIdOffset);RandomVectorScorerSupplier finalscorerSupplier = buildScorerSupplier(finalVectorValues);HnswGraphBuilder finalBuilder =- HnswGraphBuilder.create(+ InitializedHnswGraphBuilder.fromGraph(finalscorerSupplier,10,30,seed,initializerGraph,initializerOrdMap,- finalVectorValues.size());+ BitSet.of(+ DocIdSetIterator.range(docIdOffset, initializerSize + docIdOffset), totalSize + 1),+ totalSize);// When offset is 0, the graphs should be identical before vectors are addedassertGraphEqual(initializerGraph, finalBuilder.getGraph());@@ -506,19 +575,21 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {OnHeapHnswGraph initializerGraph = initializerBuilder.build(initializerVectors.size());AbstractMockVectorValues<T> finalVectorValues =vectorValues(totalSize, dim, initializerVectors.copy(), docIdOffset);- Map<Integer, Integer> initializerOrdMap =- createOffsetOrdinalMap(initializerSize, finalVectorValues.copy(), docIdOffset);+ int[] initializerOrdMap =+ createOffsetOrdinalMap(initializerSize, finalVectorValues, docIdOffset);RandomVectorScorerSupplier finalscorerSupplier = buildScorerSupplier(finalVectorValues);HnswGraphBuilder finalBuilder =- HnswGraphBuilder.create(+ InitializedHnswGraphBuilder.fromGraph(finalscorerSupplier,10,30,seed,initializerGraph,initializerOrdMap,- finalVectorValues.size());+ BitSet.of(+ DocIdSetIterator.range(docIdOffset, initializerSize + docIdOffset), totalSize + 1),+ totalSize);assertGraphInitializedFromGraph(finalBuilder.getGraph(), initializerGraph, initializerOrdMap);@@ -528,19 +599,19 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {assertGraphContainsGraph(finalGraph, initializerGraph, initializerOrdMap);}- private void assertGraphContainsGraph(- HnswGraph g, HnswGraph h, Map<Integer, Integer> oldToNewOrdMap) throws IOException {- for (int i = 0; i < h.numLevels(); i++) {+ private void assertGraphContainsGraph(HnswGraph g, HnswGraph initializer, int[] newOrdinals)+ throws IOException {+ for (int i = 0; i < initializer.numLevels(); i++) {int[] finalGraphNodesOnLevel = nodesIteratorToArray(g.getNodesOnLevel(i));int[] initializerGraphNodesOnLevel =- mapArrayAndSort(nodesIteratorToArray(h.getNodesOnLevel(i)), oldToNewOrdMap);+ mapArrayAndSort(nodesIteratorToArray(initializer.getNodesOnLevel(i)), newOrdinals);int overlap = computeOverlap(finalGraphNodesOnLevel, initializerGraphNodesOnLevel);assertEquals(initializerGraphNodesOnLevel.length, overlap);}}private void assertGraphInitializedFromGraph(- HnswGraph g, HnswGraph initializer, Map<Integer, Integer> oldToNewOrdMap) throws IOException {+ HnswGraph g, HnswGraph initializer, int[] newOrdinals) throws IOException {assertEquals("the number of levels in the graphs are different!",initializer.numLevels(),@@ -550,25 +621,42 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {// new ordinal mappingassertEquals("the number of nodes in the graphs are different!", initializer.size(), g.size());- // assert that all the node from initializer graph can be found in the new graph and- // the neighbors from the old graph are successfully transferred to the new graph+ // assert that the neighbors from the old graph are successfully transferred to the new graphfor (int level = 0; level < g.numLevels(); level++) {NodesIterator nodesOnLevel = initializer.getNodesOnLevel(level);while (nodesOnLevel.hasNext()) {int node = nodesOnLevel.nextInt();- g.seek(level, oldToNewOrdMap.get(node));+ g.seek(level, newOrdinals[node]);initializer.seek(level, node);assertEquals("arcs differ for node " + node,getNeighborNodes(g),getNeighborNodes(initializer).stream()- .map(oldToNewOrdMap::get)+ .map(n -> newOrdinals[n]).collect(Collectors.toSet()));}}}- private Map<Integer, Integer> createOffsetOrdinalMap(+ private int[] nodesIteratorToArray(NodesIterator nodesIterator) {+ int[] arr = new int[nodesIterator.size()];+ int i = 0;+ while (nodesIterator.hasNext()) {+ arr[i++] = nodesIterator.nextInt();+ }+ return arr;+ }++ private int[] mapArrayAndSort(int[] arr, int[] offset) {+ int[] mappedA = new int[arr.length];+ for (int i = 0; i < arr.length; i++) {+ mappedA[i] = offset[arr[i]];+ }+ Arrays.sort(mappedA);+ return mappedA;+ }++ private int[] createOffsetOrdinalMap(int docIdSize, AbstractMockVectorValues<T> totalVectorValues, int docIdOffset) {// Compute the offset for the ordinal map to be the number of non-null vectors in the total// vector values@@ -577,35 +665,17 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {while (totalVectorValues.nextDoc() < docIdOffset) {ordinalOffset++;}+ int[] offsetOrdinalMap = new int[docIdSize];- Map<Integer, Integer> offsetOrdinalMap = new HashMap<>();for (int curr = 0;totalVectorValues.docID() < docIdOffset + docIdSize;totalVectorValues.nextDoc()) {- offsetOrdinalMap.put(curr, ordinalOffset + curr++);+ offsetOrdinalMap[curr] = ordinalOffset + curr++;}return offsetOrdinalMap;}- private int[] nodesIteratorToArray(NodesIterator nodesIterator) {- int[] arr = new int[nodesIterator.size()];- int i = 0;- while (nodesIterator.hasNext()) {- arr[i++] = nodesIterator.nextInt();- }- return arr;- }-- private int[] mapArrayAndSort(int[] arr, Map<Integer, Integer> map) {- int[] mappedA = new int[arr.length];- for (int i = 0; i < arr.length; i++) {- mappedA[i] = map.get(arr[i]);- }- Arrays.sort(mappedA);- return mappedA;- }-@SuppressWarnings("unchecked")public void testVisitedLimit() throws IOException {int nDoc = 500;@@ -1083,7 +1153,7 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {static float[][] createRandomFloatVectors(int size, int dimension, Random random) {float[][] vectors = new float[size][];- for (int offset = 0; offset < size; offset += random.nextInt(3) + 1) {+ for (int offset = 0; offset < size; offset++) {vectors[offset] = randomVector(random, dimension);}return vectors;@@ -1091,7 +1161,7 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {static byte[][] createRandomByteVectors(int size, int dimension, Random random) {byte[][] vectors = new byte[size][];- for (int offset = 0; offset < size; offset += random.nextInt(3) + 1) {+ for (int offset = 0; offset < size; offset++) {vectors[offset] = randomVector8(random, dimension);}return vectors;diff --git a/lucene/core/src/test/org/apache/lucene/util/hnsw/MockByteVectorValues.java b/lucene/core/src/test/org/apache/lucene/util/hnsw/MockByteVectorValues.javaindex 08e8c1f1cc4..453948924ed 100644--- a/lucene/core/src/test/org/apache/lucene/util/hnsw/MockByteVectorValues.java+++ b/lucene/core/src/test/org/apache/lucene/util/hnsw/MockByteVectorValues.java@@ -24,7 +24,12 @@ class MockByteVectorValues extends AbstractMockVectorValues<byte[]> {private final byte[] scratch;static MockByteVectorValues fromValues(byte[][] values) {- int dimension = values[0].length;+ byte[] firstNonNull = null;+ int j = 0;+ while (firstNonNull == null && j < values.length) {+ firstNonNull = values[j++];+ }+ int dimension = firstNonNull.length;int maxDoc = values.length;byte[][] denseValues = new byte[maxDoc][];int count = 0;diff --git a/lucene/core/src/test/org/apache/lucene/util/hnsw/MockVectorValues.java b/lucene/core/src/test/org/apache/lucene/util/hnsw/MockVectorValues.javaindex 22c8a9dffc6..0892195d5eb 100644--- a/lucene/core/src/test/org/apache/lucene/util/hnsw/MockVectorValues.java+++ b/lucene/core/src/test/org/apache/lucene/util/hnsw/MockVectorValues.java@@ -24,7 +24,12 @@ class MockVectorValues extends AbstractMockVectorValues<float[]> {private final float[] scratch;static MockVectorValues fromValues(float[][] values) {- int dimension = values[0].length;+ float[] firstNonNull = null;+ int j = 0;+ while (firstNonNull == null && j < values.length) {+ firstNonNull = values[j++];+ }+ int dimension = firstNonNull.length;int maxDoc = values.length;float[][] denseValues = new float[maxDoc][];int count = 0;