perf: AVX2 Teddy, bidirectional DFA fallback, CompositeSequenceDFA fixes (#114)

perf: enable AVX2 Teddy, fix CompositeSequenceDFA overmatching, add digit-run skip

Author: kolkov

CHANGELOG.md

@@ -12,6 +12,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ARM NEON SIMD support (waiting for Go 1.26 native SIMD)
 - SIMD prefilter for CompositeSequenceDFA (#83)
 
+## [0.12.1] - 2026-02-15
+
+### Performance
+- **DFA bidirectional fallback for BoundedBacktracker** — When BoundedBacktracker
+  can't handle large inputs (exceeds 32M entry limit), use forward DFA + reverse
+  DFA instead of PikeVM. Forward DFA finds match end, reverse DFA finds match
+  start. O(n) total vs PikeVM's O(n*states). ~3x speedup on `(\w{2,8})+` at 6MB.
+- **Digit-run skip optimization** — For `\d+`-leading patterns (IP addresses,
+  version numbers), skip entire digit run on DFA failure instead of advancing
+  one byte at a time. Only enabled when the leading digit class has a greedy
+  unbounded quantifier.
+
+### Fixed
+- **Bounded repetitions blocked ReverseSuffix strategy** (Issue #115) —
+  `isSafeForReverseSuffix` didn't recognize `OpRepeat{min>=1}` as a wildcard
+  subexpression, blocking UseReverseSuffix for patterns with bounded repetitions
+  like `{1,50}{1,10}`. These patterns fell to NFA full-scan instead of suffix
+  prefilter + reverse DFA. Fix: **2500ms → 0.5ms** (5000x) on 100KB no-match.
+- **CompositeSequenceDFA overmatching for bounded patterns** — Bare character
+  classes like `\w` (maxMatch=1) were treated as unbounded by the DFA, causing
+  `\w\w` on "000" to return "000" instead of "00". Now rejects patterns with
+  bounded maxMatch, falling back to CompositeSearcher backtracking.
+- **AVX2 Teddy assembly correctness** (Issue #74) — Fixed `teddySlimAVX2_2`
+  returning position -1 (not-found sentinel) for valid candidates in short
+  haystacks, caused by `DECQ SI` executing when there was no prior chunk
+  boundary to cover. AVX2 dispatch remains disabled by default (SSSE3 is 4x
+  faster on AMD EPYC due to VZEROUPPER overhead on frequent verification
+  restarts).
+
 ## [0.12.0] - 2026-02-06
 
 ### Performance

meta/compile.go

@@ -98,12 +98,14 @@ func buildOnePassDFA(re *syntax.Regexp, nfaEngine *nfa.NFA, config Config) *onep
 // strategyEngines holds all strategy-specific engines built by buildStrategyEngines.
 type strategyEngines struct {
 	dfa                            *lazy.DFA
+	reverseDFA                     *lazy.DFA // Reverse DFA for bidirectional search fallback
 	reverseSearcher                *ReverseAnchoredSearcher
 	reverseSuffixSearcher          *ReverseSuffixSearcher
 	reverseSuffixSetSearcher       *ReverseSuffixSetSearcher
 	reverseInnerSearcher           *ReverseInnerSearcher
 	multilineReverseSuffixSearcher *MultilineReverseSuffixSearcher // Issue #97
 	digitPrefilter                 *prefilter.DigitPrefilter
+	digitRunSkipSafe               bool
 	ahoCorasick                    *ahocorasick.Automaton
 	finalStrategy                  Strategy
 }
@@ -141,7 +143,8 @@ func buildStrategyEngines(
 	needsDFA := strategy == UseDFA || strategy == UseBoth ||
 		strategy == UseReverseAnchored || strategy == UseReverseSuffix ||
 		strategy == UseReverseSuffixSet || strategy == UseReverseInner ||
-		strategy == UseMultilineReverseSuffix || strategy == UseDigitPrefilter
+		strategy == UseMultilineReverseSuffix || strategy == UseDigitPrefilter ||
+		strategy == UseBoundedBacktracker
 
 	if !needsDFA {
 		return result
@@ -164,9 +167,25 @@ func buildStrategyEngines(
 		}
 	}
 
+	// Build forward+reverse DFA for BoundedBacktracker bidirectional fallback.
+	// When BoundedBacktracker can't handle large inputs (CanHandle fails),
+	// bidirectional DFA (forward→end, reverse→start) is O(n) vs PikeVM's O(n*states).
+	if result.finalStrategy == UseBoundedBacktracker {
+		fwdDFA, err := lazy.CompileWithPrefilter(nfaEngine, dfaConfig, pf)
+		if err == nil {
+			result.dfa = fwdDFA
+			reverseNFA := nfa.ReverseAnchored(nfaEngine)
+			revDFA, revErr := lazy.CompileWithConfig(reverseNFA, dfaConfig)
+			if revErr == nil {
+				result.reverseDFA = revDFA
+			}
+		}
+	}
+
 	// For digit prefilter strategy, create the digit prefilter
 	if result.finalStrategy == UseDigitPrefilter {
 		result.digitPrefilter = prefilter.NewDigitPrefilter()
+		result.digitRunSkipSafe = isDigitRunSkipSafe(re)
 	}
 
 	return result
@@ -490,6 +509,7 @@ func CompileRegexp(re *syntax.Regexp, config Config) (*Engine, error) {
 		asciiNFA:                       asciiNFAEngine,
 		asciiBoundedBacktracker:        asciiBT,
 		dfa:                            engines.dfa,
+		reverseDFA:                     engines.reverseDFA,
 		pikevm:                         pikevm,
 		boundedBacktracker:             charClassResult.boundedBT,
 		charClassSearcher:              charClassResult.charClassSrch,
@@ -504,6 +524,7 @@ func CompileRegexp(re *syntax.Regexp, config Config) (*Engine, error) {
 		reverseInnerSearcher:           engines.reverseInnerSearcher,
 		multilineReverseSuffixSearcher: engines.multilineReverseSuffixSearcher,
 		digitPrefilter:                 engines.digitPrefilter,
+		digitRunSkipSafe:               engines.digitRunSkipSafe,
 		ahoCorasick:                    engines.ahoCorasick,
 		anchoredLiteralInfo:            anchoredLiteralInfo,
 		prefilter:                      pf,

meta/engine.go

@@ -99,6 +99,13 @@ type Engine struct {
 	// Note: The cache is now stored in pooled SearchState for thread-safety
 	onepass *onepass.DFA
 
+	// reverseDFA is a reverse lazy DFA for bidirectional search fallback.
+	// When BoundedBacktracker can't handle large inputs, forward DFA finds
+	// match end and reverseDFA finds match start. O(n) total.
+	// Placed after onepass to preserve field offsets of hot-path fields
+	// (charClassSearcher, strategy, etc.) for cache alignment stability.
+	reverseDFA *lazy.DFA
+
 	// statePool provides thread-safe pooling of per-search mutable state.
 	// This enables concurrent searches on the same Engine instance.
 	statePool *searchStatePool
@@ -115,6 +122,12 @@ type Engine struct {
 	// isStartAnchored is true if the pattern is anchored at start (^).
 	// Used for first-byte prefilter optimization.
 	isStartAnchored bool
+
+	// digitRunSkipSafe is true when the leading digit class has a greedy
+	// unbounded quantifier (\d+, \d*). On DFA failure, all positions in the
+	// same digit run produce the same result, so the inner loop can skip
+	// the entire run instead of trying each digit.
+	digitRunSkipSafe bool
 }
 
 // Stats tracks execution statistics for performance analysis.

meta/find_indices.go

@@ -483,6 +483,25 @@ func (e *Engine) findIndicesMultilineReverseSuffixAt(haystack []byte, at int) (i
 	return e.multilineReverseSuffixSearcher.FindIndicesAt(haystack, at)
 }
 
+// findIndicesBidirectionalDFA uses forward DFA + reverse DFA for exact match bounds.
+// Forward DFA finds match end, reverse DFA finds match start. O(n) total.
+// Used as fallback when BoundedBacktracker can't handle large inputs.
+func (e *Engine) findIndicesBidirectionalDFA(haystack []byte, at int) (int, int, bool) {
+	atomic.AddUint64(&e.stats.DFASearches, 1)
+	end := e.dfa.FindAt(haystack, at)
+	if end == -1 {
+		return -1, -1, false
+	}
+	if end == at {
+		return at, at, true // Empty match
+	}
+	start := e.reverseDFA.SearchReverse(haystack, at, end)
+	if start < 0 {
+		return -1, -1, false // Reverse DFA failed (cache full)
+	}
+	return start, end, true
+}
+
 // findIndicesBoundedBacktracker searches using bounded backtracker - zero alloc.
 // Thread-safe: uses pooled state.
 func (e *Engine) findIndicesBoundedBacktracker(haystack []byte) (int, int, bool) {
@@ -499,7 +518,10 @@ func (e *Engine) findIndicesBoundedBacktracker(haystack []byte) (int, int, bool)
 
 	atomic.AddUint64(&e.stats.NFASearches, 1)
 	if !e.boundedBacktracker.CanHandle(len(haystack)) {
-		// Use optimized SlotTable-based search for large inputs
+		// Bidirectional DFA: O(n) vs PikeVM's O(n*states) for large inputs
+		if e.dfa != nil && e.reverseDFA != nil {
+			return e.findIndicesBidirectionalDFA(haystack, 0)
+		}
 		return e.pikevm.SearchWithSlotTable(haystack, nfa.SearchModeFind)
 	}
 
@@ -529,21 +551,33 @@ func (e *Engine) findIndicesBoundedBacktrackerAt(haystack []byte, at int) (int,
 	// to search the remaining portion, not the full haystack.
 	remaining := haystack[at:]
 
-	// V11-002 ASCII optimization
-	if e.asciiBoundedBacktracker != nil && simd.IsASCII(remaining) {
-		if !e.asciiBoundedBacktracker.CanHandle(len(remaining)) {
-			// Use optimized SlotTable-based search for large inputs
-			return e.pikevm.SearchWithSlotTableAt(haystack, at, nfa.SearchModeFind)
+	// V11-002 ASCII optimization.
+	// For start-anchored patterns, limit the IsASCII check to a small prefix
+	// to avoid O(n) scan of the entire input when only position 0 matters.
+	if e.asciiBoundedBacktracker != nil {
+		asciiCheck := remaining
+		if e.isStartAnchored && len(asciiCheck) > 4096 {
+			asciiCheck = asciiCheck[:4096]
 		}
-		start, end, found := e.asciiBoundedBacktracker.Search(remaining)
-		if found {
-			return at + start, at + end, true
+		if simd.IsASCII(asciiCheck) {
+			if !e.asciiBoundedBacktracker.CanHandle(len(remaining)) {
+				if e.dfa != nil && e.reverseDFA != nil {
+					return e.findIndicesBidirectionalDFA(haystack, at)
+				}
+				return e.pikevm.SearchWithSlotTableAt(haystack, at, nfa.SearchModeFind)
+			}
+			start, end, found := e.asciiBoundedBacktracker.Search(remaining)
+			if found {
+				return at + start, at + end, true
+			}
+			return -1, -1, false
 		}
-		return -1, -1, false
 	}
 
 	if !e.boundedBacktracker.CanHandle(len(remaining)) {
-		// Delegate to NFA path which uses prefilter if available
+		if e.dfa != nil && e.reverseDFA != nil {
+			return e.findIndicesBidirectionalDFA(haystack, at)
+		}
 		return e.findIndicesNFAAt(haystack, at)
 	}
 
@@ -730,6 +764,14 @@ func (e *Engine) findIndicesDigitPrefilter(haystack []byte) (int, int, bool) {
 		}
 
 		pos = digitPos + 1
+		// When the leading digit class is greedy unbounded (\d+, \d*), all
+		// positions in the same digit run reach the same DFA state after
+		// consuming digits, so they all fail identically. Skip the entire run.
+		if e.digitRunSkipSafe {
+			for pos < len(haystack) && haystack[pos] >= '0' && haystack[pos] <= '9' {
+				pos++
+			}
+		}
 	}
 
 	return -1, -1, false
@@ -767,6 +809,11 @@ func (e *Engine) findIndicesDigitPrefilterAt(haystack []byte, at int) (int, int,
 		}
 
 		pos = digitPos + 1
+		if e.digitRunSkipSafe {
+			for pos < len(haystack) && haystack[pos] >= '0' && haystack[pos] <= '9' {
+				pos++
+			}
+		}
 	}
 
 	return -1, -1, false
@@ -931,46 +978,52 @@ func (e *Engine) findIndicesBoundedBacktrackerAtWithState(haystack []byte, at in
 	// to search the remaining portion, not the full haystack.
 	remaining := haystack[at:]
 
-	// V11-002 ASCII optimization
-	if e.asciiBoundedBacktracker != nil && simd.IsASCII(remaining) {
-		if !e.asciiBoundedBacktracker.CanHandle(len(remaining)) {
-			// V12 Windowed BoundedBacktracker for ASCII path
-			maxInput := e.asciiBoundedBacktracker.MaxInputSize()
-			if maxInput > 0 && len(remaining) > maxInput {
-				window := remaining[:maxInput]
-				start, end, found := e.asciiBoundedBacktracker.Search(window)
-				if found {
-					return at + start, at + end, true
+	// V11-002 ASCII optimization.
+	// For start-anchored patterns, limit the IsASCII check to a small prefix
+	// to avoid O(n) scan of the entire input when only position 0 matters.
+	if e.asciiBoundedBacktracker != nil {
+		asciiCheck := remaining
+		if e.isStartAnchored && len(asciiCheck) > 4096 {
+			asciiCheck = asciiCheck[:4096]
+		}
+		if simd.IsASCII(asciiCheck) {
+			if !e.asciiBoundedBacktracker.CanHandle(len(remaining)) {
+				// Bidirectional DFA: O(n) vs PikeVM's O(n*states)
+				if e.dfa != nil && e.reverseDFA != nil {
+					return e.findIndicesBidirectionalDFA(haystack, at)
+				}
+				// V12 Windowed BoundedBacktracker for ASCII path
+				maxInput := e.asciiBoundedBacktracker.MaxInputSize()
+				if maxInput > 0 && len(remaining) > maxInput {
+					window := remaining[:maxInput]
+					start, end, found := e.asciiBoundedBacktracker.Search(window)
+					if found {
+						return at + start, at + end, true
+					}
 				}
+				return state.pikevm.SearchWithSlotTableAt(haystack, at, nfa.SearchModeFind)
 			}
-			return state.pikevm.SearchWithSlotTableAt(haystack, at, nfa.SearchModeFind)
-		}
-		start, end, found := e.asciiBoundedBacktracker.Search(remaining)
-		if found {
-			return at + start, at + end, true
+			start, end, found := e.asciiBoundedBacktracker.Search(remaining)
+			if found {
+				return at + start, at + end, true
+			}
+			return -1, -1, false
 		}
-		return -1, -1, false
 	}
 
 	if !e.boundedBacktracker.CanHandle(len(remaining)) {
-		// V12 Windowed BoundedBacktracker: For large inputs, try searching in a
-		// window of maxInputSize bytes first. Most patterns produce short matches
-		// (e.g., word patterns like (\w{2,8})+ match 2-8 chars), so the match
-		// will be found within the first window. Only fall back to PikeVM if
-		// no match is found in the window (rare for common patterns).
+		// Bidirectional DFA: O(n) vs PikeVM's O(n*states) for large inputs
+		if e.dfa != nil && e.reverseDFA != nil {
+			return e.findIndicesBidirectionalDFA(haystack, at)
+		}
+		// V12 Windowed BoundedBacktracker fallback
 		maxInput := e.boundedBacktracker.MaxInputSize()
 		if maxInput > 0 && len(remaining) > maxInput {
-			// Search in the first window
 			window := remaining[:maxInput]
 			start, end, found := e.boundedBacktracker.SearchWithState(window, state.backtracker)
 			if found {
-				// Match found within window - this is the common case
 				return at + start, at + end, true
 			}
-			// No match in window - could be:
-			// 1. No match exists in the full input
-			// 2. Match exists beyond the window
-			// Fall back to PikeVM to handle both cases correctly
 		}
 		return state.pikevm.SearchWithSlotTableAt(haystack, at, nfa.SearchModeFind)
 	}