Apache Lucene open-source search software
Reuse HNSW graph for intialization during merge (#12050)
John Mazanec776149f0f696
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txtindex 1bc6cfe3ccd..a55713e33ef 100644--- a/lucene/CHANGES.txt+++ b/lucene/CHANGES.txt@@ -133,6 +133,8 @@ Optimizations* GITHUB#12128, GITHUB#12133: Speed up docvalues set query by making use of sortedness. (Robert Muir, Uwe Schindler)+* GITHUB#12050: Reuse HNSW graph for intialization during merge (Jack Mazanec)+Bug Fixes---------------------(No changes)diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswVectorsReader.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswVectorsReader.javaindex 2b46cb498ab..8e66d075587 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswVectorsReader.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene91/Lucene91HnswVectorsReader.java@@ -561,9 +561,9 @@ public final class Lucene91HnswVectorsReader extends KnnVectorsReader {@Overridepublic NodesIterator getNodesOnLevel(int level) {if (level == 0) {- return new NodesIterator(size());+ return new ArrayNodesIterator(size());} else {- return new NodesIterator(nodesByLevel[level], nodesByLevel[level].length);+ return new ArrayNodesIterator(nodesByLevel[level], nodesByLevel[level].length);}}}diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene91/Lucene91OnHeapHnswGraph.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene91/Lucene91OnHeapHnswGraph.javaindex 2d3ef582b47..e762e016bbf 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene91/Lucene91OnHeapHnswGraph.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene91/Lucene91OnHeapHnswGraph.java@@ -163,9 +163,9 @@ public final class Lucene91OnHeapHnswGraph extends HnswGraph {@Overridepublic NodesIterator getNodesOnLevel(int level) {if (level == 0) {- return new NodesIterator(size());+ return new ArrayNodesIterator(size());} else {- return new NodesIterator(nodesByLevel.get(level), graph.get(level).size());+ return new ArrayNodesIterator(nodesByLevel.get(level), graph.get(level).size());}}}diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene92/Lucene92HnswVectorsReader.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene92/Lucene92HnswVectorsReader.javaindex 8fb1b3a92d3..df51972e8dd 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene92/Lucene92HnswVectorsReader.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene92/Lucene92HnswVectorsReader.java@@ -457,9 +457,9 @@ public final class Lucene92HnswVectorsReader extends KnnVectorsReader {@Overridepublic NodesIterator getNodesOnLevel(int level) {if (level == 0) {- return new NodesIterator(size());+ return new ArrayNodesIterator(size());} else {- return new NodesIterator(nodesByLevel[level], nodesByLevel[level].length);+ return new ArrayNodesIterator(nodesByLevel[level], nodesByLevel[level].length);}}}diff --git a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene94/Lucene94HnswVectorsReader.java b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene94/Lucene94HnswVectorsReader.javaindex 51a9aa23c27..ee6472ab2d6 100644--- a/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene94/Lucene94HnswVectorsReader.java+++ b/lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene94/Lucene94HnswVectorsReader.java@@ -533,9 +533,9 @@ public final class Lucene94HnswVectorsReader extends KnnVectorsReader {@Overridepublic NodesIterator getNodesOnLevel(int level) {if (level == 0) {- return new NodesIterator(size());+ return new ArrayNodesIterator(size());} else {- return new NodesIterator(nodesByLevel[level], nodesByLevel[level].length);+ return new ArrayNodesIterator(nodesByLevel[level], nodesByLevel[level].length);}}}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 2e125c82462..f6f37802760 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@@ -345,7 +345,7 @@ public final class Lucene94HnswVectorsWriter extends KnnVectorsWriter {if (level == 0) {return graph.getNodesOnLevel(0);} else {- return new NodesIterator(nodesByLevel.get(level), nodesByLevel.get(level).length);+ return new ArrayNodesIterator(nodesByLevel.get(level), nodesByLevel.get(level).length);}}};@@ -687,10 +687,7 @@ public final class Lucene94HnswVectorsWriter extends KnnVectorsWriter {assert docID > lastDocID;docsWithField.add(docID);vectors.add(copyValue(vectorValue));- if (node > 0) {- // start at node 1! node 0 is added implicitly, in the constructor- hnswGraphBuilder.addGraphNode(node, vectorValue);- }+ hnswGraphBuilder.addGraphNode(node, vectorValue);node++;lastDocID = docID;}diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene95/Lucene95HnswVectorsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene95/Lucene95HnswVectorsReader.javaindex 8d140b1fa1e..185a472b5f4 100644--- a/lucene/core/src/java/org/apache/lucene/codecs/lucene95/Lucene95HnswVectorsReader.java+++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene95/Lucene95HnswVectorsReader.java@@ -573,9 +573,9 @@ public final class Lucene95HnswVectorsReader extends KnnVectorsReader {@Overridepublic NodesIterator getNodesOnLevel(int level) {if (level == 0) {- return new NodesIterator(size());+ return new ArrayNodesIterator(size());} else {- return new NodesIterator(nodesByLevel[level], nodesByLevel[level].length);+ return new ArrayNodesIterator(nodesByLevel[level], nodesByLevel[level].length);}}}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 e9180d63d33..bf0b79807f0 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,11 +25,16 @@ 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.KnnFieldVectorsWriter;+import org.apache.lucene.codecs.KnnVectorsReader;import org.apache.lucene.codecs.KnnVectorsWriter;import org.apache.lucene.codecs.lucene90.IndexedDISI;+import org.apache.lucene.codecs.perfield.PerFieldKnnVectorsFormat;import org.apache.lucene.index.*;import org.apache.lucene.index.Sorter;import org.apache.lucene.search.DocIdSetIterator;@@ -357,7 +362,7 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {if (level == 0) {return graph.getNodesOnLevel(0);} else {- return new NodesIterator(nodesByLevel.get(level), nodesByLevel.get(level).length);+ return new ArrayNodesIterator(nodesByLevel.get(level), nodesByLevel.get(level).length);}}};@@ -424,6 +429,7 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {int[][] vectorIndexNodeOffsets = null;if (docsWithField.cardinality() != 0) {// build graph+ int initializerIndex = selectGraphForInitialization(mergeState, fieldInfo);graph =switch (fieldInfo.getVectorEncoding()) {case BYTE -> {@@ -434,13 +440,7 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {vectorDataInput,byteSize);HnswGraphBuilder<byte[]> hnswGraphBuilder =- HnswGraphBuilder.create(- vectorValues,- fieldInfo.getVectorEncoding(),- fieldInfo.getVectorSimilarityFunction(),- M,- beamWidth,- HnswGraphBuilder.randSeed);+ createHnswGraphBuilder(mergeState, fieldInfo, vectorValues, initializerIndex);hnswGraphBuilder.setInfoStream(segmentWriteState.infoStream);yield hnswGraphBuilder.build(vectorValues.copy());}@@ -452,13 +452,7 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {vectorDataInput,byteSize);HnswGraphBuilder<float[]> hnswGraphBuilder =- HnswGraphBuilder.create(- vectorValues,- fieldInfo.getVectorEncoding(),- fieldInfo.getVectorSimilarityFunction(),- M,- beamWidth,- HnswGraphBuilder.randSeed);+ createHnswGraphBuilder(mergeState, fieldInfo, vectorValues, initializerIndex);hnswGraphBuilder.setInfoStream(segmentWriteState.infoStream);yield hnswGraphBuilder.build(vectorValues.copy());}@@ -489,6 +483,189 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {}}+ private <T> HnswGraphBuilder<T> createHnswGraphBuilder(+ MergeState mergeState,+ FieldInfo fieldInfo,+ RandomAccessVectorValues<T> floatVectorValues,+ int initializerIndex)+ throws IOException {+ if (initializerIndex == -1) {+ return HnswGraphBuilder.create(+ floatVectorValues,+ fieldInfo.getVectorEncoding(),+ fieldInfo.getVectorSimilarityFunction(),+ M,+ beamWidth,+ HnswGraphBuilder.randSeed);+ }++ HnswGraph initializerGraph =+ getHnswGraphFromReader(fieldInfo.name, mergeState.knnVectorsReaders[initializerIndex]);+ Map<Integer, Integer> ordinalMapper =+ getOldToNewOrdinalMap(mergeState, fieldInfo, initializerIndex);+ return HnswGraphBuilder.create(+ floatVectorValues,+ fieldInfo.getVectorEncoding(),+ fieldInfo.getVectorSimilarityFunction(),+ M,+ beamWidth,+ HnswGraphBuilder.randSeed,+ initializerGraph,+ ordinalMapper);+ }++ 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 Lucene95HnswVectorsReader/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 Lucene95HnswVectorsReader candidateReader)) {+ continue;+ }++ int candidateVectorCount = 0;+ switch (fieldInfo.getVectorEncoding()) {+ case BYTE -> {+ ByteVectorValues byteVectorValues = candidateReader.getByteVectorValues(fieldInfo.name);+ if (byteVectorValues == null) {+ continue;+ }+ candidateVectorCount = byteVectorValues.size();+ }+ case FLOAT32 -> {+ FloatVectorValues vectorValues = candidateReader.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 Lucene95HnswVectorsReader fieldReader) {+ return fieldReader.getGraph(fieldName);+ }++ if (knnVectorsReader instanceof Lucene95HnswVectorsReader) {+ return ((Lucene95HnswVectorsReader) knnVectorsReader).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.@@ -735,10 +912,7 @@ public final class Lucene95HnswVectorsWriter extends KnnVectorsWriter {assert docID > lastDocID;docsWithField.add(docID);vectors.add(copyValue(vectorValue));- if (node > 0) {- // start at node 1! node 0 is added implicitly, in the constructor- hnswGraphBuilder.addGraphNode(node, vectorValue);- }+ hnswGraphBuilder.addGraphNode(node, vectorValue);node++;lastDocID = docID;}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 fc7b0be82fb..9086ab55d2e 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,8 @@ package org.apache.lucene.util.hnsw;import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;import java.io.IOException;+import java.util.Collection;+import java.util.Iterator;import java.util.NoSuchElementException;import java.util.PrimitiveIterator;import org.apache.lucene.index.FloatVectorValues;@@ -115,7 +117,7 @@ public abstract class HnswGraph {@Overridepublic NodesIterator getNodesOnLevel(int level) {- return NodesIterator.EMPTY;+ return ArrayNodesIterator.EMPTY;}};@@ -123,33 +125,50 @@ public abstract class HnswGraph {* Iterator over the graph nodes on a certain level, Iterator also provides the size – the total* number of nodes to be iterated over.*/- public static final class NodesIterator implements PrimitiveIterator.OfInt {- static NodesIterator EMPTY = new NodesIterator(0);-- private final int[] nodes;- private final int size;- int cur = 0;-- /** Constructor for iterator based on the nodes array up to the size */- public NodesIterator(int[] nodes, int size) {- assert nodes != null;- assert size <= nodes.length;- this.nodes = nodes;- this.size = size;- }+ public abstract static class NodesIterator implements PrimitiveIterator.OfInt {+ protected final int size;/** Constructor for iterator based on the size */public NodesIterator(int size) {- this.nodes = null;this.size = size;}+ /** The number of elements in this iterator * */+ public int size() {+ return size;+ }+/*** Consume integers from the iterator and place them into the `dest` array.** @param dest where to put the integers* @return The number of integers written to `dest`*/+ public abstract int consume(int[] dest);+ }++ /** NodesIterator that accepts nodes as an integer array. */+ public static class ArrayNodesIterator extends NodesIterator {+ static NodesIterator EMPTY = new ArrayNodesIterator(0);++ private final int[] nodes;+ private int cur = 0;++ /** Constructor for iterator based on integer array representing nodes */+ public ArrayNodesIterator(int[] nodes, int size) {+ super(size);+ assert nodes != null;+ assert size <= nodes.length;+ this.nodes = nodes;+ }++ /** Constructor for iterator based on the size */+ public ArrayNodesIterator(int size) {+ super(size);+ this.nodes = null;+ }++ @Overridepublic int consume(int[] dest) {if (hasNext() == false) {throw new NoSuchElementException();@@ -182,10 +201,43 @@ public abstract class HnswGraph {public boolean hasNext() {return cur < size;}+ }- /** The number of elements in this iterator * */- public int size() {- return size;+ /** Nodes iterator based on set representation of nodes. */+ public static class CollectionNodesIterator extends NodesIterator {+ Iterator<Integer> nodes;++ /** Constructor for iterator based on collection representing nodes */+ public CollectionNodesIterator(Collection<Integer> nodes) {+ super(nodes.size());+ this.nodes = nodes.iterator();+ }++ @Override+ public int consume(int[] dest) {+ if (hasNext() == false) {+ throw new NoSuchElementException();+ }++ int destIndex = 0;+ while (hasNext() && destIndex < dest.length) {+ dest[destIndex++] = nextInt();+ }++ return destIndex;+ }++ @Override+ public int nextInt() {+ if (hasNext() == false) {+ throw new NoSuchElementException();+ }+ return nodes.next();+ }++ @Override+ public boolean hasNext() {+ return nodes.hasNext();}}}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 e2932993261..9f1e6c50525 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,10 +18,14 @@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.index.VectorEncoding;@@ -63,6 +67,7 @@ public final class HnswGraphBuilder<T> {// we need two sources of vectors in order to perform diversity check comparisons without// collidingprivate final RandomAccessVectorValues<T> vectorsCopy;+ private final Set<Integer> initializedNodes;public static <T> HnswGraphBuilder<T> create(RandomAccessVectorValues<T> vectors,@@ -75,6 +80,22 @@ public final class HnswGraphBuilder<T> {return new HnswGraphBuilder<>(vectors, vectorEncoding, similarityFunction, M, beamWidth, seed);}+ public static <T> HnswGraphBuilder<T> create(+ RandomAccessVectorValues<T> vectors,+ VectorEncoding vectorEncoding,+ VectorSimilarityFunction similarityFunction,+ int M,+ int beamWidth,+ long seed,+ HnswGraph initializerGraph,+ Map<Integer, Integer> oldToNewOrdinalMap)+ throws IOException {+ HnswGraphBuilder<T> hnswGraphBuilder =+ new HnswGraphBuilder<>(vectors, vectorEncoding, similarityFunction, M, beamWidth, seed);+ hnswGraphBuilder.initializeFromGraph(initializerGraph, oldToNewOrdinalMap);+ return hnswGraphBuilder;+ }+/*** 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.@@ -110,8 +131,7 @@ public final class HnswGraphBuilder<T> {// normalization factor for level generation; currently not configurablethis.ml = M == 1 ? 1 : 1 / Math.log(1.0 * M);this.random = new SplittableRandom(seed);- int levelOfFirstNode = getRandomGraphLevel(ml, random);- this.hnsw = new OnHeapHnswGraph(M, levelOfFirstNode);+ this.hnsw = new OnHeapHnswGraph(M);this.graphSearcher =new HnswGraphSearcher<>(vectorEncoding,@@ -120,6 +140,7 @@ public final class HnswGraphBuilder<T> {new FixedBitSet(this.vectors.size()));// in scratch we store candidates in reverse order: worse candidates are firstscratch = new NeighborArray(Math.max(beamWidth, M + 1), false);+ this.initializedNodes = new HashSet<>();}/**@@ -142,10 +163,64 @@ public final class HnswGraphBuilder<T> {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;+ float[] vectorValue = null;+ byte[] binaryValue = null;+ for (int level = 0; level < initializerGraph.numLevels(); 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);+ }++ switch (this.vectorEncoding) {+ case FLOAT32 -> vectorValue = (float[]) vectors.vectorValue(newOrd);+ case BYTE -> binaryValue = (byte[]) vectors.vectorValue(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);+ float score =+ switch (this.vectorEncoding) {+ case FLOAT32 -> this.similarityFunction.compare(+ vectorValue, (float[]) vectorsCopy.vectorValue(newNeighbor));+ case BYTE -> this.similarityFunction.compare(+ binaryValue, (byte[]) vectorsCopy.vectorValue(newNeighbor));+ };+ newNeighbors.insertSorted(newNeighbor, score);+ }+ }+ }+ }+private void addVectors(RandomAccessVectorValues<T> vectorsToAdd) throws IOException {long start = System.nanoTime(), t = start;- // start at node 1! node 0 is added implicitly, in the constructor- for (int node = 1; node < vectorsToAdd.size(); node++) {+ for (int node = 0; node < vectorsToAdd.size(); node++) {+ if (initializedNodes.contains(node)) {+ continue;+ }addGraphNode(node, vectorsToAdd);if ((node % 10000 == 0) && infoStream.isEnabled(HNSW_COMPONENT)) {t = printGraphBuildStatus(node, start, t);@@ -167,6 +242,14 @@ public final class HnswGraphBuilder<T> {NeighborQueue candidates;final int nodeLevel = getRandomGraphLevel(ml, random);int curMaxLevel = hnsw.numLevels() - 1;++ // If entrynode is -1, then this should finish without adding neighbors+ if (hnsw.entryNode() == -1) {+ for (int level = nodeLevel; level >= 0; level--) {+ hnsw.addNode(level, node);+ }+ return;+ }int[] eps = new int[] {hnsw.entryNode()};// if a node introduces new levels to the graph, add this new node on new levelsdiff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphSearcher.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphSearcher.javaindex 13a338e0d18..4857d5b9d57 100644--- a/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphSearcher.java+++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/HnswGraphSearcher.java@@ -101,7 +101,12 @@ public class HnswGraphSearcher<T> {new NeighborQueue(topK, true),new SparseFixedBitSet(vectors.size()));NeighborQueue results;- int[] eps = new int[] {graph.entryNode()};++ int initialEp = graph.entryNode();+ if (initialEp == -1) {+ return new NeighborQueue(1, true);+ }+ int[] eps = new int[] {initialEp};int numVisited = 0;for (int level = graph.numLevels() - 1; level >= 1; level--) {results = graphSearcher.searchLevel(query, 1, level, eps, vectors, graph, null, visitedLimit);diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/OnHeapHnswGraph.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/OnHeapHnswGraph.javaindex 78137c2a630..9862536de08 100644--- a/lucene/core/src/java/org/apache/lucene/util/hnsw/OnHeapHnswGraph.java+++ b/lucene/core/src/java/org/apache/lucene/util/hnsw/OnHeapHnswGraph.java@@ -20,10 +20,9 @@ package org.apache.lucene.util.hnsw;import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;import java.util.ArrayList;-import java.util.Arrays;import java.util.List;+import java.util.TreeMap;import org.apache.lucene.util.Accountable;-import org.apache.lucene.util.ArrayUtil;import org.apache.lucene.util.RamUsageEstimator;/**@@ -33,19 +32,20 @@ import org.apache.lucene.util.RamUsageEstimator;public final class OnHeapHnswGraph extends HnswGraph implements Accountable {private int numLevels; // the current number of levels in the graph- private int entryNode; // the current graph entry node on the top level+ private int entryNode; // the current graph entry node on the top level. -1 if not set- // Nodes by level expressed as the level 0's nodes' ordinals.- // As level 0 contains all nodes, nodesByLevel.get(0) is null.- private final List<int[]> nodesByLevel;-- // graph is a list of graph levels.- // Each level is represented as List<NeighborArray> – nodes' connections on this level.+ // Level 0 is represented as List<NeighborArray> – nodes' connections on level 0.// Each entry in the list has the top maxConn/maxConn0 neighbors of a node. The nodes correspond// to vectors// added to HnswBuilder, and the node values are the ordinals of those vectors.// Thus, on all levels, neighbors expressed as the level 0's nodes' ordinals.- private final List<List<NeighborArray>> graph;+ private final List<NeighborArray> graphLevel0;+ // Represents levels 1-N. Each level is represented with a TreeMap that maps a levels level 0+ // ordinal to its neighbors on that level. All nodes are in level 0, so we do not need to maintain+ // it in this list. However, to avoid changing list indexing, we always will make the first+ // element+ // null.+ private final List<TreeMap<Integer, NeighborArray>> graphUpperLevels;private final int nsize;private final int nsize0;@@ -53,24 +53,17 @@ public final class OnHeapHnswGraph extends HnswGraph implements Accountable {private int upto;private NeighborArray cur;- OnHeapHnswGraph(int M, int levelOfFirstNode) {- this.numLevels = levelOfFirstNode + 1;- this.graph = new ArrayList<>(numLevels);- this.entryNode = 0;+ OnHeapHnswGraph(int M) {+ this.numLevels = 1; // Implicitly start the graph with a single level+ this.graphLevel0 = new ArrayList<>();+ this.entryNode = -1; // Entry node should be negative until a node is added// Neighbours' size on upper levels (nsize) and level 0 (nsize0)// We allocate extra space for neighbours, but then prune them to keep allowed maximumthis.nsize = M + 1;this.nsize0 = (M * 2 + 1);- for (int l = 0; l < numLevels; l++) {- graph.add(new ArrayList<>());- graph.get(l).add(new NeighborArray(l == 0 ? nsize0 : nsize, true));- }- this.nodesByLevel = new ArrayList<>(numLevels);- nodesByLevel.add(null); // we don't need this for 0th level, as it contains all nodes- for (int l = 1; l < numLevels; l++) {- nodesByLevel.add(new int[] {0});- }+ this.graphUpperLevels = new ArrayList<>(numLevels);+ graphUpperLevels.add(null); // we don't need this for 0th level, as it contains all nodes}/**@@ -81,49 +74,52 @@ public final class OnHeapHnswGraph extends HnswGraph implements Accountable {*/public NeighborArray getNeighbors(int level, int node) {if (level == 0) {- return graph.get(level).get(node);+ return graphLevel0.get(node);}- int nodeIndex = Arrays.binarySearch(nodesByLevel.get(level), 0, graph.get(level).size(), node);- assert nodeIndex >= 0;- return graph.get(level).get(nodeIndex);+ TreeMap<Integer, NeighborArray> levelMap = graphUpperLevels.get(level);+ assert levelMap.containsKey(node);+ return levelMap.get(node);}@Overridepublic int size() {- return graph.get(0).size(); // all nodes are located on the 0th level+ return graphLevel0.size(); // all nodes are located on the 0th level}/**- * Add node on the given level+ * Add node on the given level. Nodes can be inserted out of order, but it requires that the nodes+ * preceded by the node inserted out of order are eventually added.** @param level level to add a node on* @param node the node to add, represented as an ordinal on the level 0.*/public void addNode(int level, int node) {+ if (entryNode == -1) {+ entryNode = node;+ }+if (level > 0) {// if the new node introduces a new level, add more levels to the graph,// and make this node the graph's new entry pointif (level >= numLevels) {for (int i = numLevels; i <= level; i++) {- graph.add(new ArrayList<>());- nodesByLevel.add(new int[] {node});+ graphUpperLevels.add(new TreeMap<>());}numLevels = level + 1;entryNode = node;- } else {- // Add this node id to this level's nodes- int[] nodes = nodesByLevel.get(level);- int idx = graph.get(level).size();- if (idx < nodes.length) {- nodes[idx] = node;- } else {- nodes = ArrayUtil.grow(nodes);- nodes[idx] = node;- nodesByLevel.set(level, nodes);- }+ }++ graphUpperLevels.get(level).put(node, new NeighborArray(nsize, true));+ } else {+ // Add nodes all the way up to and including "node" in the new graph on level 0. This will+ // cause the size of the+ // graph to differ from the number of nodes added to the graph. The size of the graph and the+ // number of nodes+ // added will only be in sync once all nodes from 0...last_node are added into the graph.+ while (node >= graphLevel0.size()) {+ graphLevel0.add(new NeighborArray(nsize0, true));}}- graph.get(level).add(new NeighborArray(level == 0 ? nsize0 : nsize, true));}@Override@@ -164,9 +160,9 @@ public final class OnHeapHnswGraph extends HnswGraph implements Accountable {@Overridepublic NodesIterator getNodesOnLevel(int level) {if (level == 0) {- return new NodesIterator(size());+ return new ArrayNodesIterator(size());} else {- return new NodesIterator(nodesByLevel.get(level), graph.get(level).size());+ return new CollectionNodesIterator(graphUpperLevels.get(level).keySet());}}@@ -184,19 +180,26 @@ public final class OnHeapHnswGraph extends HnswGraph implements Accountable {+ Integer.BYTES * 2;long total = 0;for (int l = 0; l < numLevels; l++) {- int numNodesOnLevel = graph.get(l).size();if (l == 0) {total +=- numNodesOnLevel * neighborArrayBytes0+ graphLevel0.size() * neighborArrayBytes0+ RamUsageEstimator.NUM_BYTES_OBJECT_REF; // for graph;} else {+ long numNodesOnLevel = graphUpperLevels.get(l).size();++ // For levels > 0, we represent the graph structure with a tree map.+ // A single node in the tree contains 3 references (left root, right root, value) as well+ // as an Integer for the key and 1 extra byte for the color of the node (this is actually 1+ // bit, but+ // because we do not have that granularity, we set to 1 byte). In addition, we include 1+ // more reference for+ // the tree map itself.total +=- nodesByLevel.get(l).length * Integer.BYTES- + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER- + RamUsageEstimator.NUM_BYTES_OBJECT_REF; // for nodesByLevel- total +=- numNodesOnLevel * neighborArrayBytes- + RamUsageEstimator.NUM_BYTES_OBJECT_REF; // for graph;+ numNodesOnLevel * (3L * RamUsageEstimator.NUM_BYTES_OBJECT_REF + Integer.BYTES + 1)+ + RamUsageEstimator.NUM_BYTES_OBJECT_REF;++ // Add the size neighbor of each node+ total += numNodesOnLevel * neighborArrayBytes;}}return total;diff --git a/lucene/core/src/test/org/apache/lucene/index/TestKnnGraph.java b/lucene/core/src/test/org/apache/lucene/index/TestKnnGraph.javaindex bba92fab222..08f089430ba 100644--- a/lucene/core/src/test/org/apache/lucene/index/TestKnnGraph.java+++ b/lucene/core/src/test/org/apache/lucene/index/TestKnnGraph.java@@ -48,14 +48,12 @@ import org.apache.lucene.search.SearcherManager;import org.apache.lucene.search.TopDocs;import org.apache.lucene.store.Directory;import org.apache.lucene.tests.util.LuceneTestCase;-import org.apache.lucene.util.ArrayUtil;import org.apache.lucene.util.Bits;import org.apache.lucene.util.BytesRef;import org.apache.lucene.util.IOUtils;import org.apache.lucene.util.VectorUtil;import org.apache.lucene.util.hnsw.HnswGraph;import org.apache.lucene.util.hnsw.HnswGraph.NodesIterator;-import org.apache.lucene.util.hnsw.HnswGraphBuilder;import org.junit.After;import org.junit.Before;@@ -179,21 +177,6 @@ public class TestKnnGraph extends LuceneTestCase {}}- /**- * Verify that we get the *same* graph by indexing one segment as we do by indexing two segments- * and merging.- */- public void testMergeProducesSameGraph() throws Exception {- long seed = random().nextLong();- int numDoc = atLeast(100);- int dimension = atLeast(10);- float[][] values = randomVectors(numDoc, dimension);- int mergePoint = random().nextInt(numDoc);- int[][][] mergedGraph = getIndexedGraph(values, mergePoint, seed);- int[][][] singleSegmentGraph = getIndexedGraph(values, -1, seed);- assertGraphEquals(singleSegmentGraph, mergedGraph);- }-/** Test writing and reading of multiple vector fields * */public void testMultipleVectorFields() throws Exception {int numVectorFields = randomIntBetween(2, 5);@@ -227,52 +210,6 @@ public class TestKnnGraph extends LuceneTestCase {}}- private void assertGraphEquals(int[][][] expected, int[][][] actual) {- assertEquals("graph sizes differ", expected.length, actual.length);- for (int level = 0; level < expected.length; level++) {- for (int node = 0; node < expected[level].length; node++) {- assertArrayEquals("difference at ord=" + node, expected[level][node], actual[level][node]);- }- }- }-- /**- * Return a naive representation of an HNSW graph as a 3 dimensional array: 1st dim represents a- * graph layer. Each layer contains an array of arrays – a list of nodes and for each node a list- * of the node's neighbours. 2nd dim represents a node on a layer, and contains the node's- * neighbourhood, or {@code null} if a node is not present on this layer. 3rd dim represents- * neighbours of a node.- */- private int[][][] getIndexedGraph(float[][] values, int mergePoint, long seed)- throws IOException {- HnswGraphBuilder.randSeed = seed;- int[][][] graph;- try (Directory dir = newDirectory()) {- IndexWriterConfig iwc = newIndexWriterConfig();- iwc.setMergePolicy(new LogDocMergePolicy()); // for predictable segment ordering when merging- iwc.setCodec(codec); // don't use SimpleTextCodec- try (IndexWriter iw = new IndexWriter(dir, iwc)) {- for (int i = 0; i < values.length; i++) {- add(iw, i, values[i]);- if (i == mergePoint) {- // flush proactively to create a segment- iw.flush();- }- }- iw.forceMerge(1);- }- try (IndexReader reader = DirectoryReader.open(dir)) {- PerFieldKnnVectorsFormat.FieldsReader perFieldReader =- (PerFieldKnnVectorsFormat.FieldsReader)- ((CodecReader) getOnlyLeafReader(reader)).getVectorReader();- Lucene95HnswVectorsReader vectorReader =- (Lucene95HnswVectorsReader) perFieldReader.getFieldReader(KNN_GRAPH_FIELD);- graph = copyGraph(vectorReader.getGraph(KNN_GRAPH_FIELD));- }- }- return graph;- }-private float[][] randomVectors(int numDoc, int dimension) {float[][] values = new float[numDoc][];for (int i = 0; i < numDoc; i++) {@@ -297,27 +234,6 @@ public class TestKnnGraph extends LuceneTestCase {return value;}- int[][][] copyGraph(HnswGraph graphValues) throws IOException {- int[][][] graph = new int[graphValues.numLevels()][][];- int size = graphValues.size();- int[] scratch = new int[M * 2];-- for (int level = 0; level < graphValues.numLevels(); level++) {- NodesIterator nodesItr = graphValues.getNodesOnLevel(level);- graph[level] = new int[size][];- while (nodesItr.hasNext()) {- int node = nodesItr.nextInt();- graphValues.seek(level, node);- int n, count = 0;- while ((n = graphValues.nextNeighbor()) != NO_MORE_DOCS) {- scratch[count++] = n;- }- graph[level][node] = ArrayUtil.copyOfSubArray(scratch, 0, count);- }- }- return graph;- }-/** Verify that searching does something reasonable */public void testSearch() throws Exception {// We can't use dot product here since the vectors are laid out on a grid, not a sphere.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 10ce6b42a78..80c9c7a93cf 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@@ -25,10 +25,14 @@ import com.carrotsearch.randomizedtesting.RandomizedTest;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.Map;import java.util.Random;import java.util.Set;+import java.util.stream.Collectors;import org.apache.lucene.codecs.KnnVectorsFormat;import org.apache.lucene.codecs.lucene95.Lucene95Codec;import org.apache.lucene.codecs.lucene95.Lucene95HnswVectorsFormat;@@ -84,6 +88,12 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {abstract AbstractMockVectorValues<T> vectorValues(LeafReader reader, String fieldName)throws IOException;+ abstract AbstractMockVectorValues<T> vectorValues(+ int size,+ int dimension,+ AbstractMockVectorValues<T> pregeneratedVectorValues,+ int pregeneratedOffset);+abstract Field knnVectorField(String name, T vector, VectorSimilarityFunction similarityFunction);abstract RandomAccessVectorValues<T> circularVectorValues(int nDoc);@@ -427,6 +437,238 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {}}+ public void testBuildOnHeapHnswGraphOutOfOrder() throws IOException {+ int maxNumLevels = randomIntBetween(2, 10);+ int nodeCount = randomIntBetween(1, 100);++ List<List<Integer>> nodesPerLevel = new ArrayList<>();+ for (int i = 0; i < maxNumLevels; i++) {+ nodesPerLevel.add(new ArrayList<>());+ }++ int numLevels = 0;+ for (int currNode = 0; currNode < nodeCount; currNode++) {+ int nodeMaxLevel = random().nextInt(1, maxNumLevels + 1);+ numLevels = Math.max(numLevels, nodeMaxLevel);+ for (int currLevel = 0; currLevel < nodeMaxLevel; currLevel++) {+ nodesPerLevel.get(currLevel).add(currNode);+ }+ }++ OnHeapHnswGraph topDownOrderReversedHnsw = new OnHeapHnswGraph(10);+ for (int currLevel = numLevels - 1; currLevel >= 0; currLevel--) {+ List<Integer> currLevelNodes = nodesPerLevel.get(currLevel);+ int currLevelNodesSize = currLevelNodes.size();+ for (int currNodeInd = currLevelNodesSize - 1; currNodeInd >= 0; currNodeInd--) {+ topDownOrderReversedHnsw.addNode(currLevel, currLevelNodes.get(currNodeInd));+ }+ }++ OnHeapHnswGraph bottomUpOrderReversedHnsw = new OnHeapHnswGraph(10);+ for (int currLevel = 0; currLevel < numLevels; currLevel++) {+ List<Integer> currLevelNodes = nodesPerLevel.get(currLevel);+ int currLevelNodesSize = currLevelNodes.size();+ for (int currNodeInd = currLevelNodesSize - 1; currNodeInd >= 0; currNodeInd--) {+ bottomUpOrderReversedHnsw.addNode(currLevel, currLevelNodes.get(currNodeInd));+ }+ }++ OnHeapHnswGraph topDownOrderRandomHnsw = new OnHeapHnswGraph(10);+ for (int currLevel = numLevels - 1; currLevel >= 0; currLevel--) {+ List<Integer> currLevelNodes = new ArrayList<>(nodesPerLevel.get(currLevel));+ Collections.shuffle(currLevelNodes, random());+ for (Integer currNode : currLevelNodes) {+ topDownOrderRandomHnsw.addNode(currLevel, currNode);+ }+ }++ OnHeapHnswGraph bottomUpExpectedHnsw = new OnHeapHnswGraph(10);+ for (int currLevel = 0; currLevel < numLevels; currLevel++) {+ for (Integer currNode : nodesPerLevel.get(currLevel)) {+ bottomUpExpectedHnsw.addNode(currLevel, currNode);+ }+ }++ assertEquals(nodeCount, bottomUpExpectedHnsw.getNodesOnLevel(0).size());+ for (Integer node : nodesPerLevel.get(0)) {+ assertEquals(0, bottomUpExpectedHnsw.getNeighbors(0, node).size());+ }++ for (int currLevel = 1; currLevel < numLevels; currLevel++) {+ NodesIterator nodesIterator = bottomUpExpectedHnsw.getNodesOnLevel(currLevel);+ List<Integer> expectedNodesOnLevel = nodesPerLevel.get(currLevel);+ assertEquals(expectedNodesOnLevel.size(), nodesIterator.size());+ for (Integer expectedNode : expectedNodesOnLevel) {+ int currentNode = nodesIterator.nextInt();+ assertEquals(expectedNode.intValue(), currentNode);+ assertEquals(0, bottomUpExpectedHnsw.getNeighbors(currLevel, currentNode).size());+ }+ }++ assertGraphEqual(bottomUpExpectedHnsw, topDownOrderReversedHnsw);+ assertGraphEqual(bottomUpExpectedHnsw, bottomUpOrderReversedHnsw);+ assertGraphEqual(bottomUpExpectedHnsw, topDownOrderRandomHnsw);+ }++ public void testHnswGraphBuilderInitializationFromGraph_withOffsetZero() throws IOException {+ int totalSize = atLeast(100);+ int initializerSize = random().nextInt(5, totalSize);+ int docIdOffset = 0;+ int dim = atLeast(10);+ long seed = random().nextLong();++ AbstractMockVectorValues<T> initializerVectors = vectorValues(initializerSize, dim);+ HnswGraphBuilder<T> initializerBuilder =+ HnswGraphBuilder.create(+ initializerVectors, getVectorEncoding(), similarityFunction, 10, 30, seed);++ OnHeapHnswGraph initializerGraph = initializerBuilder.build(initializerVectors.copy());+ AbstractMockVectorValues<T> finalVectorValues =+ vectorValues(totalSize, dim, initializerVectors, docIdOffset);++ Map<Integer, Integer> initializerOrdMap =+ createOffsetOrdinalMap(initializerSize, finalVectorValues, docIdOffset);++ HnswGraphBuilder<T> finalBuilder =+ HnswGraphBuilder.create(+ finalVectorValues,+ getVectorEncoding(),+ similarityFunction,+ 10,+ 30,+ seed,+ initializerGraph,+ initializerOrdMap);++ // When offset is 0, the graphs should be identical before vectors are added+ assertGraphEqual(initializerGraph, finalBuilder.getGraph());++ OnHeapHnswGraph finalGraph = finalBuilder.build(finalVectorValues.copy());+ assertGraphContainsGraph(finalGraph, initializerGraph, initializerOrdMap);+ }++ public void testHnswGraphBuilderInitializationFromGraph_withNonZeroOffset() throws IOException {+ int totalSize = atLeast(100);+ int initializerSize = random().nextInt(5, totalSize);+ int docIdOffset = random().nextInt(1, totalSize - initializerSize + 1);+ int dim = atLeast(10);+ long seed = random().nextLong();++ AbstractMockVectorValues<T> initializerVectors = vectorValues(initializerSize, dim);+ HnswGraphBuilder<T> initializerBuilder =+ HnswGraphBuilder.create(+ initializerVectors.copy(), getVectorEncoding(), similarityFunction, 10, 30, seed);+ OnHeapHnswGraph initializerGraph = initializerBuilder.build(initializerVectors.copy());+ AbstractMockVectorValues<T> finalVectorValues =+ vectorValues(totalSize, dim, initializerVectors.copy(), docIdOffset);+ Map<Integer, Integer> initializerOrdMap =+ createOffsetOrdinalMap(initializerSize, finalVectorValues.copy(), docIdOffset);++ HnswGraphBuilder<T> finalBuilder =+ HnswGraphBuilder.create(+ finalVectorValues,+ getVectorEncoding(),+ similarityFunction,+ 10,+ 30,+ seed,+ initializerGraph,+ initializerOrdMap);++ assertGraphInitializedFromGraph(finalBuilder.getGraph(), initializerGraph, initializerOrdMap);++ // Confirm that the graph is appropriately constructed by checking that the nodes in the old+ // graph are present in the levels of the new graph+ OnHeapHnswGraph finalGraph = finalBuilder.build(finalVectorValues.copy());+ 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++) {+ int[] finalGraphNodesOnLevel = nodesIteratorToArray(g.getNodesOnLevel(i));+ int[] initializerGraphNodesOnLevel =+ mapArrayAndSort(nodesIteratorToArray(h.getNodesOnLevel(i)), oldToNewOrdMap);+ int overlap = computeOverlap(finalGraphNodesOnLevel, initializerGraphNodesOnLevel);+ assertEquals(initializerGraphNodesOnLevel.length, overlap);+ }+ }++ private void assertGraphInitializedFromGraph(+ HnswGraph g, HnswGraph h, Map<Integer, Integer> oldToNewOrdMap) throws IOException {+ assertEquals("the number of levels in the graphs are different!", g.numLevels(), h.numLevels());+ // Confirm that the size of the new graph includes all nodes up to an including the max new+ // ordinal in the old to+ // new ordinal mapping+ assertEquals(+ "the number of nodes in the graphs are different!",+ g.size(),+ Collections.max(oldToNewOrdMap.values()) + 1);++ // assert the nodes from the previous graph are successfully to levels > 0 in the new graph+ for (int level = 1; level < g.numLevels(); level++) {+ NodesIterator nodesOnLevel = g.getNodesOnLevel(level);+ NodesIterator nodesOnLevel2 = h.getNodesOnLevel(level);+ while (nodesOnLevel.hasNext() && nodesOnLevel2.hasNext()) {+ int node = nodesOnLevel.nextInt();+ int node2 = oldToNewOrdMap.get(nodesOnLevel2.nextInt());+ assertEquals("nodes in the graphs are different", node, node2);+ }+ }++ // assert that the neighbors from the old graph are successfully transferred to the new graph+ for (int level = 0; level < g.numLevels(); level++) {+ NodesIterator nodesOnLevel = h.getNodesOnLevel(level);+ while (nodesOnLevel.hasNext()) {+ int node = nodesOnLevel.nextInt();+ g.seek(level, oldToNewOrdMap.get(node));+ h.seek(level, node);+ assertEquals(+ "arcs differ for node " + node,+ getNeighborNodes(g),+ getNeighborNodes(h).stream().map(oldToNewOrdMap::get).collect(Collectors.toSet()));+ }+ }+ }++ private Map<Integer, Integer> 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+ // before the docIdOffset+ int ordinalOffset = 0;+ while (totalVectorValues.nextDoc() < docIdOffset) {+ ordinalOffset++;+ }++ Map<Integer, Integer> offsetOrdinalMap = new HashMap<>();+ for (int curr = 0;+ totalVectorValues.docID() < docIdOffset + docIdSize;+ totalVectorValues.nextDoc()) {+ offsetOrdinalMap.put(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;@@ -531,8 +773,8 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {HnswGraphBuilder.create(vectors, getVectorEncoding(), similarityFunction, 2, 10, random().nextInt());// node 0 is added by the builder constructor- // builder.addGraphNode(vectors.vectorValue(0));RandomAccessVectorValues<T> vectorsCopy = vectors.copy();+ builder.addGraphNode(0, vectorsCopy);builder.addGraphNode(1, vectorsCopy);builder.addGraphNode(2, vectorsCopy);// now every node has tried to attach every other node as a neighbor, but@@ -586,9 +828,8 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {HnswGraphBuilder<T> builder =HnswGraphBuilder.create(vectors, getVectorEncoding(), similarityFunction, 1, 10, random().nextInt());- // node 0 is added by the builder constructor- // builder.addGraphNode(vectors.vectorValue(0));RandomAccessVectorValues<T> vectorsCopy = vectors.copy();+ builder.addGraphNode(0, vectorsCopy);builder.addGraphNode(1, vectorsCopy);builder.addGraphNode(2, vectorsCopy);assertLevel0Neighbors(builder.hnsw, 0, 1, 2);@@ -619,9 +860,8 @@ abstract class HnswGraphTestCase<T> extends LuceneTestCase {HnswGraphBuilder<T> builder =HnswGraphBuilder.create(vectors, getVectorEncoding(), similarityFunction, 1, 10, random().nextInt());- // node 0 is added by the builder constructor- // builder.addGraphNode(vectors.vectorValue(0));RandomAccessVectorValues<T> vectorsCopy = vectors.copy();+ builder.addGraphNode(0, vectorsCopy);builder.addGraphNode(1, vectorsCopy);builder.addGraphNode(2, vectorsCopy);assertLevel0Neighbors(builder.hnsw, 0, 1, 2);diff --git a/lucene/core/src/test/org/apache/lucene/util/hnsw/TestHnswByteVectorGraph.java b/lucene/core/src/test/org/apache/lucene/util/hnsw/TestHnswByteVectorGraph.javaindex 258864ade7d..3a2d92ff92a 100644--- a/lucene/core/src/test/org/apache/lucene/util/hnsw/TestHnswByteVectorGraph.java+++ b/lucene/core/src/test/org/apache/lucene/util/hnsw/TestHnswByteVectorGraph.java@@ -85,6 +85,34 @@ public class TestHnswByteVectorGraph extends HnswGraphTestCase<byte[]> {return MockByteVectorValues.fromValues(bValues);}+ @Override+ AbstractMockVectorValues<byte[]> vectorValues(+ int size,+ int dimension,+ AbstractMockVectorValues<byte[]> pregeneratedVectorValues,+ int pregeneratedOffset) {+ byte[][] vectors = new byte[size][];+ byte[][] randomVectors =+ createRandomByteVectors(size - pregeneratedVectorValues.values.length, dimension, random());++ for (int i = 0; i < pregeneratedOffset; i++) {+ vectors[i] = randomVectors[i];+ }++ int currentDoc;+ while ((currentDoc = pregeneratedVectorValues.nextDoc()) != NO_MORE_DOCS) {+ vectors[pregeneratedOffset + currentDoc] = pregeneratedVectorValues.values[currentDoc];+ }++ for (int i = pregeneratedOffset + pregeneratedVectorValues.values.length;+ i < vectors.length;+ i++) {+ vectors[i] = randomVectors[i - pregeneratedVectorValues.values.length];+ }++ return MockByteVectorValues.fromValues(vectors);+ }+@OverrideAbstractMockVectorValues<byte[]> vectorValues(LeafReader reader, String fieldName)throws IOException {diff --git a/lucene/core/src/test/org/apache/lucene/util/hnsw/TestHnswFloatVectorGraph.java b/lucene/core/src/test/org/apache/lucene/util/hnsw/TestHnswFloatVectorGraph.javaindex 16f2e7330e2..5dda5bf0a83 100644--- a/lucene/core/src/test/org/apache/lucene/util/hnsw/TestHnswFloatVectorGraph.java+++ b/lucene/core/src/test/org/apache/lucene/util/hnsw/TestHnswFloatVectorGraph.java@@ -79,6 +79,35 @@ public class TestHnswFloatVectorGraph extends HnswGraphTestCase<float[]> {return MockVectorValues.fromValues(vectors);}+ @Override+ AbstractMockVectorValues<float[]> vectorValues(+ int size,+ int dimension,+ AbstractMockVectorValues<float[]> pregeneratedVectorValues,+ int pregeneratedOffset) {+ float[][] vectors = new float[size][];+ float[][] randomVectors =+ createRandomFloatVectors(+ size - pregeneratedVectorValues.values.length, dimension, random());++ for (int i = 0; i < pregeneratedOffset; i++) {+ vectors[i] = randomVectors[i];+ }++ int currentDoc;+ while ((currentDoc = pregeneratedVectorValues.nextDoc()) != NO_MORE_DOCS) {+ vectors[pregeneratedOffset + currentDoc] = pregeneratedVectorValues.values[currentDoc];+ }++ for (int i = pregeneratedOffset + pregeneratedVectorValues.values.length;+ i < vectors.length;+ i++) {+ vectors[i] = randomVectors[i - pregeneratedVectorValues.values.length];+ }++ return MockVectorValues.fromValues(vectors);+ }+@OverrideField knnVectorField(String name, float[] vector, VectorSimilarityFunction similarityFunction) {return new KnnFloatVectorField(name, vector, similarityFunction);