Three strategies are compared: + * + *
Both benchmarks include the populate step (setting bits + scores) to simulate the full + * inner-window lifecycle. + */ +@BenchmarkMode(Mode.Throughput) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@State(Scope.Benchmark) +@Warmup(iterations = 5, time = 1) +@Measurement(iterations = 5, time = 1) +@Fork( + value = 1, + jvmArgsAppend = {"-Xmx1g", "-Xms1g", "-XX:+AlwaysPreTouch"}) +public class WindowExtractionBenchmark { + + static final int INNER_WINDOW_SIZE = 1 << 12; // 4096, same as MaxScoreBulkScorer + + /** + * Number of matching documents in the window. Realistic values range from very sparse (10) to + * moderately dense (2000). Multi-term boolean queries typically match 50-500 docs per window. + */ + @Param({"10", "50", "128", "500", "1000", "2000"}) + int matchCount; + + private final SplittableRandom random = new SplittableRandom(42); + + // Simulates MaxScoreBulkScorer's fields + private FixedBitSet windowMatches; + private double[] windowScores; + private int innerWindowMin; + + // Output buffers (pre-allocated to max size, like MaxScoreBulkScorer reuses them) + private int[] outDocs; + private double[] outScores; + private int outSize; + + // Pre-computed match positions and scores for deterministic setup + private int[] matchPositions; + private double[] matchScoreValues; + + @Setup(Level.Trial) + public void setupTrial() { + windowMatches = new FixedBitSet(INNER_WINDOW_SIZE); + windowScores = new double[INNER_WINDOW_SIZE]; + // +1 for denseWord2Array sentinel slot + outDocs = new int[INNER_WINDOW_SIZE + 1]; + outScores = new double[INNER_WINDOW_SIZE + 1]; + outSize = 0; + innerWindowMin = 100_000; // arbitrary base doc ID + + // Pre-compute random match positions + matchPositions = new int[matchCount]; + matchScoreValues = new double[matchCount]; + FixedBitSet temp = new FixedBitSet(INNER_WINDOW_SIZE); + int count = 0; + while (count < matchCount) { + int pos = random.nextInt(INNER_WINDOW_SIZE); + if (!temp.get(pos)) { + temp.set(pos); + matchPositions[count] = pos; + matchScoreValues[count] = random.nextDouble() * 10.0; + count++; + } + } + Arrays.sort(matchPositions); + } + + /** Populate the bitset and windowScores — simulates what the essential clause collection does. */ + private void populateWindow() { + for (int i = 0; i < matchPositions.length; i++) { + int pos = matchPositions[i]; + windowMatches.set(pos); + windowScores[pos] = matchScoreValues[i]; + } + } + + /** + * ORIGINAL: cardinality() + forEach(lambda) + clear(). This is what the code did before any + * optimization — 3 passes over the bitset. + */ + @Benchmark + public int oldCardinalityForEach(Blackhole bh) throws IOException { + populateWindow(); + int innerWindowSize = INNER_WINDOW_SIZE; + + // Pass 1: count bits to pre-size buffer + int card = windowMatches.cardinality(0, innerWindowSize); + // In original code: docAndScoreAccBuffer.growNoCopy(card) + // We simulate with pre-allocated buffer, but cardinality() cost is still measured + + // Pass 2: forEach with lambda to extract docs + scores + zero scores + outSize = 0; + windowMatches.forEach( + 0, + innerWindowSize, + 0, + (IOIntConsumer) + index -> { + outDocs[outSize] = innerWindowMin + index; + outScores[outSize] = windowScores[index]; + outSize++; + windowScores[index] = 0d; + }); + + // Pass 3: clear the bitset + windowMatches.clear(0, innerWindowSize); + + bh.consume(card); + bh.consume(outScores); + return outSize; + } + + /** + * OPTIMIZED: forEach(lambda) + clear() with pre-allocated buffer. Eliminates the cardinality() + * pass — 2 passes over the bitset. This is the current implementation. + */ + @Benchmark + public int newForEachNoCardinality(Blackhole bh) throws IOException { + populateWindow(); + int innerWindowSize = INNER_WINDOW_SIZE; + + // No cardinality pass needed — buffer pre-allocated to INNER_WINDOW_SIZE + + // Single extraction pass: forEach with lambda + outSize = 0; + windowMatches.forEach( + 0, + innerWindowSize, + 0, + (IOIntConsumer) + index -> { + outDocs[outSize] = innerWindowMin + index; + outScores[outSize] = windowScores[index]; + outSize++; + windowScores[index] = 0d; + }); + + // Clear the bitset + windowMatches.clear(0, innerWindowSize); + + bh.consume(outScores); + return outSize; + } + + /** + * ALTERNATIVE: intoArray() + score gather loop + clear(). Uses the optimized branchless + * denseWord2Array for bit extraction — best for dense windows. + */ + @Benchmark + public int newIntoArray(Blackhole bh) { + populateWindow(); + int innerWindowSize = INNER_WINDOW_SIZE; + + // Single pass: extract doc IDs and get count + int count = windowMatches.intoArray(0, innerWindowSize, innerWindowMin, outDocs); + + // Gather scores using extracted indices + zero used entries + for (int i = 0; i < count; ++i) { + int index = outDocs[i] - innerWindowMin; + outScores[i] = windowScores[index]; + windowScores[index] = 0d; + } + + // Clear the bitset + windowMatches.clear(0, innerWindowSize); + + bh.consume(outScores); + return count; + } +} diff --git a/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java b/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java index 9bc732ba19e3..3dbfbc95dec7 100644 --- a/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java +++ b/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java @@ -263,7 +263,9 @@ private void scoreInnerWindowMultipleEssentialClauses( top = essentialQueue.updateTop(); } while (top.doc < innerWindowMax); - docAndScoreAccBuffer.growNoCopy(windowMatches.cardinality(0, innerWindowSize)); + // Pre-allocate to max window size to avoid a separate cardinality() pass. + // This buffer is reused across windows so the allocation is a one-time cost. + docAndScoreAccBuffer.growNoCopy(INNER_WINDOW_SIZE); docAndScoreAccBuffer.size = 0; windowMatches.forEach( 0,