regex: support perf-inline

This makes all uses of `#[inline(always)]` conditional on the
`perf-inline` feature. This should reduce compile times and binary size,
but may decrease match performance.

Author: BurntSushi

src/dfa.rs

@@ -442,7 +442,7 @@ impl CacheInner {
 }
 
 impl<'a> Fsm<'a> {
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     pub fn forward(
         prog: &'a Program,
         cache: &ProgramCache,
@@ -472,7 +472,7 @@ impl<'a> Fsm<'a> {
         dfa.exec_at(&mut cache.qcur, &mut cache.qnext, text)
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     pub fn reverse(
         prog: &'a Program,
         cache: &ProgramCache,
@@ -502,7 +502,7 @@ impl<'a> Fsm<'a> {
         dfa.exec_at_reverse(&mut cache.qcur, &mut cache.qnext, text)
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     pub fn forward_many(
         prog: &'a Program,
         cache: &ProgramCache,
@@ -550,7 +550,7 @@ impl<'a> Fsm<'a> {
     /// Executes the DFA on a forward NFA.
     ///
     /// {qcur,qnext} are scratch ordered sets which may be non-empty.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn exec_at(
         &mut self,
         qcur: &mut SparseSet,
@@ -743,7 +743,7 @@ impl<'a> Fsm<'a> {
     }
 
     /// Executes the DFA on a reverse NFA.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn exec_at_reverse(
         &mut self,
         qcur: &mut SparseSet,
@@ -848,7 +848,7 @@ impl<'a> Fsm<'a> {
     /// corresponds to text[i].
     ///
     /// This elides bounds checks, and is therefore unsafe.
-    #[inline(always)]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     unsafe fn next_si(&self, si: StatePtr, text: &[u8], i: usize) -> StatePtr {
         // What is the argument for safety here?
         // We have three unchecked accesses that could possibly violate safety:
@@ -1363,7 +1363,7 @@ impl<'a> Fsm<'a> {
     /// then it is computed, cached and a pointer to it is returned.
     ///
     /// This may return STATE_DEAD but never STATE_UNKNOWN.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn start_state(
         &mut self,
         q: &mut SparseSet,
@@ -1525,7 +1525,7 @@ impl<'a> Fsm<'a> {
 
     /// Given an input byte or the special EOF sentinel, return its
     /// corresponding byte class.
-    #[inline(always)]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn byte_class(&self, b: Byte) -> usize {
         match b.as_byte() {
             None => self.num_byte_classes() - 1,
@@ -1534,7 +1534,7 @@ impl<'a> Fsm<'a> {
     }
 
     /// Like byte_class, but explicitly for u8s.
-    #[inline(always)]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn u8_class(&self, b: u8) -> usize {
         self.prog.byte_classes[b as usize] as usize
     }

src/exec.rs

@@ -362,22 +362,22 @@ impl<'c> RegularExpression for ExecNoSyncStr<'c> {
         next_utf8(text.as_bytes(), i)
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn shortest_match_at(&self, text: &str, start: usize) -> Option<usize> {
         self.0.shortest_match_at(text.as_bytes(), start)
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn is_match_at(&self, text: &str, start: usize) -> bool {
         self.0.is_match_at(text.as_bytes(), start)
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn find_at(&self, text: &str, start: usize) -> Option<(usize, usize)> {
         self.0.find_at(text.as_bytes(), start)
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn captures_read_at(
         &self,
         locs: &mut Locations,
@@ -404,7 +404,7 @@ impl<'c> RegularExpression for ExecNoSync<'c> {
 
     /// Returns the end of a match location, possibly occurring before the
     /// end location of the correct leftmost-first match.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn shortest_match_at(&self, text: &[u8], start: usize) -> Option<usize> {
         if !self.is_anchor_end_match(text) {
             return None;
@@ -449,7 +449,7 @@ impl<'c> RegularExpression for ExecNoSync<'c> {
     ///
     /// For single regular expressions, this is equivalent to calling
     /// shortest_match(...).is_some().
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn is_match_at(&self, text: &[u8], start: usize) -> bool {
         if !self.is_anchor_end_match(text) {
             return false;
@@ -495,7 +495,7 @@ impl<'c> RegularExpression for ExecNoSync<'c> {
 
     /// Finds the start and end location of the leftmost-first match, starting
     /// at the given location.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn find_at(&self, text: &[u8], start: usize) -> Option<(usize, usize)> {
         if !self.is_anchor_end_match(text) {
             return None;
@@ -639,7 +639,7 @@ impl<'c> RegularExpression for ExecNoSync<'c> {
 
 impl<'c> ExecNoSync<'c> {
     /// Finds the leftmost-first match using only literal search.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn find_literals(
         &self,
         ty: MatchLiteralType,
@@ -682,7 +682,7 @@ impl<'c> ExecNoSync<'c> {
     ///
     /// If the result returned indicates that the DFA quit, then another
     /// matching engine should be used.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn find_dfa_forward(
         &self,
         text: &[u8],
@@ -721,7 +721,7 @@ impl<'c> ExecNoSync<'c> {
     ///
     /// If the result returned indicates that the DFA quit, then another
     /// matching engine should be used.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn find_dfa_anchored_reverse(
         &self,
         text: &[u8],
@@ -742,15 +742,15 @@ impl<'c> ExecNoSync<'c> {
     }
 
     /// Finds the end of the shortest match using only the DFA.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn shortest_dfa(&self, text: &[u8], start: usize) -> dfa::Result<usize> {
         dfa::Fsm::forward(&self.ro.dfa, self.cache, true, text, start)
     }
 
     /// Finds the end of the shortest match using only the DFA by scanning for
     /// suffix literals.
     ///
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn shortest_dfa_reverse_suffix(
         &self,
         text: &[u8],
@@ -775,7 +775,7 @@ impl<'c> ExecNoSync<'c> {
     ///
     /// If the result returned indicates that the DFA quit, then another
     /// matching engine should be used.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn exec_dfa_reverse_suffix(
         &self,
         text: &[u8],
@@ -819,7 +819,7 @@ impl<'c> ExecNoSync<'c> {
     ///
     /// If the result returned indicates that the DFA quit, then another
     /// matching engine should be used.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn find_dfa_reverse_suffix(
         &self,
         text: &[u8],
@@ -1118,7 +1118,7 @@ impl<'c> ExecNoSync<'c> {
         }
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn is_anchor_end_match(&self, text: &[u8]) -> bool {
         // Only do this check if the haystack is big (>1MB).
         if text.len() > (1 << 20) && self.ro.nfa.is_anchored_end {
@@ -1143,7 +1143,7 @@ impl<'c> ExecNoSyncStr<'c> {
 
 impl Exec {
     /// Get a searcher that isn't Sync.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     pub fn searcher(&self) -> ExecNoSync {
         let create =
             || Box::new(RefCell::new(ProgramCacheInner::new(&self.ro)));
@@ -1154,7 +1154,7 @@ impl Exec {
     }
 
     /// Get a searcher that isn't Sync and can match on &str.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     pub fn searcher_str(&self) -> ExecNoSyncStr {
         ExecNoSyncStr(self.searcher())
     }

src/literal.rs

@@ -80,7 +80,7 @@ impl LiteralSearcher {
     }
 
     /// Find the position of a literal in `haystack` if it exists.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     pub fn find(&self, haystack: &[u8]) -> Option<(usize, usize)> {
         use self::Matcher::*;
         match self.matcher {
@@ -339,7 +339,7 @@ impl SingleByteSet {
     }
 
     /// Faster find that special cases certain sizes to use memchr.
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn find(&self, text: &[u8]) -> Option<usize> {
         match self.dense.len() {
             0 => None,
@@ -452,7 +452,7 @@ impl FreqyPacked {
         }
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     pub fn find(&self, haystack: &[u8]) -> Option<usize> {
         let pat = &*self.pat;
         if haystack.len() < pat.len() || pat.is_empty() {
@@ -478,7 +478,7 @@ impl FreqyPacked {
         None
     }
 
-    #[inline(always)] // reduces constant overhead
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     pub fn is_suffix(&self, text: &[u8]) -> bool {
         if text.len() < self.len() {
             return false;

src/prog.rs

@@ -161,7 +161,7 @@ impl Program {
 impl Deref for Program {
     type Target = [Inst];
 
-    #[inline(always)]
+    #[cfg_attr(feature = "perf-inline", inline(always))]
     fn deref(&self) -> &Self::Target {
         &*self.insts
     }

test

@@ -10,6 +10,7 @@ cargo test
 features=(
     "std perf"
     "std perf unicode-perl"
+    "std perf-cache perf-dfa perf-literal"
 )
 for f in "${features[@]}"; do
     echo "===== FEATURE: $f ==="