perf: optimize phrase match scorer

[zhengbuqian]

Summary

Optimize Tantivy's no-scoring phrase-existence path without changing query semantics:

• Two-term slop existence uses a two-pointer check instead of materializing PositionSpans.
• Span buffers are allocated only for slop queries with more than two terms.
• Multi-term span matching stops scanning next_positions once a position inside the current span is found.

Benchmark

Standalone 1M-document in-memory index, seed 42, Count collector (no scoring), 10 warmup / 50 measured iterations. Matrix:

• Hit rates: 10% / 30% / 50% / 90%
• Phrase lengths: 2 / 3 / 5 / 10 / 30 terms
• Slop: 0 / 1 / 2

Average median speedup across the four hit rates:

Terms	Slop 0	Slop 1	Slop 2
2	1.77%	2.98%	1.23%
3	0.94%	13.55%	14.30%
5	3.70%	21.78%	22.14%
10	2.15%	26.95%	26.99%
30	2.69%	29.24%	28.91%

Across all 40 slop>0 cases the average median speedup is 18.81%. Exact-phrase (slop 0) averages 2.25% and is treated as run-to-run noise because that path was not algorithmically changed. Gains grow with phrase length on slop 1/2, peaking around 28–31% for 30-term queries.

Benchmark sources were used locally for measurement and are not included in this PR.

[aoiasd]

This early exit suggests a stronger simplification for the no-scoring existence path.

For a fixed span [L, R] and sorted next_positions, the expanded width is:

R - p,  p < L
R - L,  L <= p <= R
p - L,  p > R

Therefore the only non-dominated transitions are:

1. any position inside [L, R], which keeps the span unchanged; or
2. if none exists, the predecessor max(p < L) and successor min(p > R).

All positions farther left or right are dominated and do not need to be scanned. This permits a dedicated phrase_exists frontier algorithm:

• initialize [p, p] for the first term positions;
• sweep the ordered span frontier and the next ordered position list with one monotonic cursor;
• emit at most the unchanged span or the nearest left/right expansions whose widths fit max_slop;
• remove duplicates and any interval that contains a smaller interval.

After pruning, both span endpoints are strictly increasing. Each position is advanced at most once and each candidate is pushed/popped at most once, so one intermediate-term merge becomes O(F + P) for F frontier spans and P positions. The current nested scan remains O(S * P) in the worst case because right-side positions can be revisited for multiple spans. For K terms with roughly P states per round, this changes the existence path from O(K * P^2) to O(K * P).

Both nearest-side candidates must be retained when valid; choosing only the smaller current width is not sufficient. For example, with max_slop = 90, current span [10, 15], next positions [9, 100], and a following term at [100], keeping only [9, 15] later produces width 91 and misses the valid path [10, 100], whose final width remains 90.

This optimization should be isolated to phrase_exists: containment pruning is safe for boolean existence, while phrase_count may need occurrence-chain information.

[zhengbuqian]

good point, you can implement this in a separate pr.

[aoiasd]

One missing detail is how to generate this frontier in stack order without needing middle insertion.

Let the input frontier be I_i = [L_i, R_i], with both L_i and R_i strictly increasing after containment pruning, and let j_i = lower_bound(positions, L_i). Since L_i increases, j_i is non-decreasing.

For each span:

• If positions[j_i] <= R_i, emit only [L_i, R_i]; an in-range position leaves the span unchanged and therefore dominates every exterior expansion.
• Otherwise, the only candidates are [positions[j_i - 1], R_i] and [L_i, positions[j_i]], when those positions exist and the width fits max_slop.
• If consecutive spans have the same j_i, emit the left candidate only for the first such span. All later left candidates have the same left endpoint and a larger R_i, so the first one is contained in and dominates them. The right candidates have the same right endpoint and increasing left endpoints, so each later one replaces the previous one.

This local rule makes the surviving candidates arrive with non-decreasing left endpoints. While j_i is unchanged, the repeated left candidate is removed and all remaining candidates use the increasing L_i. When j_i advances, the new predecessor is at least the previous successor, which is at least the preceding span left endpoint, so the candidate left endpoint cannot move backward.

The output can then be maintained with a monotonic stack whose L and R are both strictly increasing:

append(candidate):
    if top.L == candidate.L and top.R <= candidate.R:
        discard candidate
    else:
        while stack is not empty and top.R >= candidate.R:
            pop top
        push candidate

The proof that comparing only the top is sufficient is now simple. Candidates arrive in non-decreasing L, so a new candidate can never belong before a retained span by L. If its R is not greater than the top R, it is contained in the top and dominates it. Because stack R values are increasing, every other interval dominated by the candidate is a contiguous suffix, removed by the same loop. Once top.R < candidate.R, neither interval contains the other, so the candidate belongs exactly at the end. Therefore no insertion into the middle is required.

A raw left candidate can have both endpoints below the current top, but only when its predecessor cursor did not advance; that candidate has already been dominated by the first left candidate in the same cursor run and must be discarded before stack insertion.

j_i advances at most P times, and every candidate is pushed and popped at most once, so a merge round is O(F + P) time and O(F_next) output space.

[aoiasd]

/lgtm