Fix performance issue on intersection & execution timeout not respected on intersection and generate_strings

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "regexsolver"
-version = "0.2.2"
+version = "0.3.0"
 edition = "2021"
 authors = ["Alexandre van Beurden"]
 repository = "https://github.com/RegexSolver/regexsolver"

src/execution_profile.rs

@@ -218,7 +218,10 @@ mod tests {
         };
         ThreadLocalParams::init_profile(&execution_profile);
 
-        assert_eq!(EngineError::OperationTimeOutError, term.generate_strings(100).unwrap_err());
+        assert_eq!(
+            EngineError::OperationTimeOutError,
+            term.generate_strings(100).unwrap_err()
+        );
 
         let run_duration = SystemTime::now()
             .duration_since(start_time)
@@ -244,7 +247,39 @@ mod tests {
         };
         ThreadLocalParams::init_profile(&execution_profile);
 
-        assert_eq!(EngineError::OperationTimeOutError, term1.difference(&term2).unwrap_err());
+        assert_eq!(
+            EngineError::OperationTimeOutError,
+            term1.difference(&term2).unwrap_err()
+        );
+
+        let run_duration = SystemTime::now()
+            .duration_since(start_time)
+            .expect("Time went backwards")
+            .as_millis();
+
+        println!("{run_duration}");
+        assert!(run_duration <= execution_profile.execution_timeout + 50);
+        Ok(())
+    }
+
+    #[test]
+    fn test_execution_timeout_intersection() -> Result<(), String> {
+        let term1 = Term::from_regex(".*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz").unwrap();
+        let term2 = Term::from_regex(".*abc.*def.*qdsqd.*sqdsqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdsqd.*sqdsqd.*qsdsqdsqdz.*abc.*def.*qdsqd.*sqdsqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz.*abc.*def.*qdqd.*qsdsqdsqdz").unwrap();
+
+        let start_time = SystemTime::now();
+        let execution_profile = ExecutionProfile {
+            max_number_of_states: 8192,
+            start_execution_time: Some(start_time),
+            execution_timeout: 100,
+            max_number_of_terms: 50,
+        };
+        ThreadLocalParams::init_profile(&execution_profile);
+
+        assert_eq!(
+            EngineError::OperationTimeOutError,
+            term1.intersection(&[term2]).unwrap_err()
+        );
 
         let run_duration = SystemTime::now()
             .duration_since(start_time)

src/fast_automaton/builder.rs

@@ -1,3 +1,5 @@
+use condition::converter::ConditionConverter;
+
 use crate::error::EngineError;
 
 use super::*;
@@ -29,11 +31,7 @@ impl FastAutomaton {
         let mut automaton: FastAutomaton = Self::new_empty();
         automaton.spanning_set = SpanningSet::new_total();
         automaton.accept(automaton.start_state);
-        automaton.add_transition_to(
-            0,
-            0,
-            &Condition::total(&automaton.spanning_set),
-        );
+        automaton.add_transition_to(0, 0, &Condition::total(&automaton.spanning_set));
         automaton
     }
 
@@ -69,14 +67,12 @@ impl FastAutomaton {
         if new_spanning_set == &self.spanning_set {
             return Ok(());
         }
+        let condition_converter = ConditionConverter::new(&self.spanning_set, new_spanning_set)?;
         for from_state in &self.transitions_vec() {
             for to_state in self.transitions_from_state(from_state) {
                 match self.transitions[*from_state].entry(to_state) {
                     Entry::Occupied(mut o) => {
-                        o.insert(
-                            o.get()
-                                .project_to(&self.spanning_set, new_spanning_set)?,
-                        );
+                        o.insert(condition_converter.convert(o.get())?);
                     }
                     Entry::Vacant(_) => {}
                 };

src/fast_automaton/condition/converter.rs

@@ -0,0 +1,168 @@
+use ahash::HashMapExt;
+use nohash_hasher::IntMap;
+
+use crate::{error::EngineError, fast_automaton::spanning_set::SpanningSet};
+
+use super::Condition;
+
+/// Converter to project [`Condition`] on a [`SpanningSet`].
+pub struct ConditionConverter<'a, 'b> {
+    from_spanning_set: &'a SpanningSet,
+    to_spanning_set: &'b SpanningSet,
+    equivalence_map: Vec<Vec<usize>>,
+}
+
+impl<'a, 'b> ConditionConverter<'a, 'b> {
+    /// Build a converter to project [`Condition`] from `from_spanning_set` to `to_spanning_set`.
+    ///
+    /// Currently this method does not check that the provided [`SpanningSet`] are actually convertible.
+    pub fn new(
+        from_spanning_set: &'a SpanningSet,
+        to_spanning_set: &'b SpanningSet,
+    ) -> Result<Self, EngineError> {
+        let mut to_base_map =
+            IntMap::with_capacity(to_spanning_set.spanning_ranges_with_rest_len());
+        for (i, base) in to_spanning_set
+            .get_spanning_ranges_with_rest()
+            .into_iter()
+            .enumerate()
+        {
+            to_base_map.insert(i, base);
+        }
+
+        let mut equivalence_map: Vec<Vec<usize>> =
+            Vec::with_capacity(from_spanning_set.get_number_of_spanning_ranges() + 1);
+        for from_base in from_spanning_set.get_spanning_ranges_with_rest().iter() {
+            let mut index = Vec::with_capacity(1);
+            for (i, to_base) in &to_base_map {
+                if from_base == to_base || from_base.has_intersection(to_base) {
+                    index.push(*i);
+                }
+            }
+            index.iter().for_each(|i| {
+                to_base_map.remove(i);
+            });
+            equivalence_map.push(index);
+        }
+
+        Ok(ConditionConverter {
+            from_spanning_set,
+            to_spanning_set,
+            equivalence_map,
+        })
+    }
+
+    /// Project the given [`Condition`] from `from_spanning_set` to `to_spanning_set`.
+    ///
+    /// If `from_spanning_set` is not convertible to `to_spanning_set` or if the given [`Condition`] is not based on `from_spanning_set`,
+    /// the resulting [`Condition`] will not have any relevance.
+    pub fn convert(&self, condition: &Condition) -> Result<Condition, EngineError> {
+        let mut new_condition = Condition::empty(self.to_spanning_set);
+        for (from_index, to_indexes) in self.equivalence_map.iter().enumerate() {
+            if let Some(has) = condition.0.get(from_index) {
+                if has && !to_indexes.is_empty() {
+                    to_indexes.iter().for_each(|&to_index| {
+                        new_condition.0.set(to_index, true);
+                    });
+                }
+            } else {
+                return Err(EngineError::ConditionIndexOutOfBound);
+            }
+        }
+
+        Ok(new_condition)
+    }
+
+    /// Returns `from_spanning_set`.
+    pub fn get_from_spanning_set(&self) -> &'a SpanningSet {
+        self.from_spanning_set
+    }
+
+    /// Returns `to_spanning_set`.
+    pub fn get_to_spanning_set(&self) -> &'b SpanningSet {
+        self.to_spanning_set
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use regex_charclass::{char::Char, irange::range::AnyRange};
+
+    use crate::Range;
+
+    use super::*;
+
+    fn get_from_spanning_set() -> SpanningSet {
+        let ranges = vec![
+            Range::new_from_range(Char::new('\0')..=Char::new('\u{2}')),
+            Range::new_from_range(Char::new('\u{4}')..=Char::new('\u{6}')),
+            Range::new_from_range(Char::new('\u{9}')..=Char::new('\u{9}')),
+        ];
+
+        SpanningSet::compute_spanning_set(&ranges)
+    }
+
+    fn get_to_spanning_set() -> SpanningSet {
+        let ranges = vec![
+            Range::new_from_range(Char::new('\0')..=Char::new('\u{1}')),
+            Range::new_from_range(Char::new('\u{2}')..=Char::new('\u{2}')),
+            Range::new_from_range(Char::new('\u{4}')..=Char::new('\u{6}')),
+            Range::new_from_range(Char::new('\u{9}')..=Char::new('\u{9}')),
+            Range::new_from_range(Char::new('\u{20}')..=Char::new('\u{22}')),
+        ];
+
+        SpanningSet::compute_spanning_set(&ranges)
+    }
+
+    #[test]
+    fn test_convert() -> Result<(), String> {
+        let from_spanning_set = get_from_spanning_set();
+        let to_spanning_set = get_to_spanning_set();
+
+        let converter = ConditionConverter::new(&from_spanning_set, &to_spanning_set).unwrap();
+
+        let empty = Condition::empty(&from_spanning_set);
+        assert!(converter.convert(&empty).unwrap().is_empty());
+
+        let total = Condition::total(&from_spanning_set);
+        assert!(converter.convert(&total).unwrap().is_total());
+
+        let range = Range::new_from_range(Char::new('\0')..=Char::new('\u{2}'));
+        let condition = Condition::from_range(&range, &from_spanning_set).unwrap();
+        assert_eq!(
+            range,
+            converter
+                .convert(&condition)
+                .unwrap()
+                .to_range(&to_spanning_set)
+                .unwrap()
+        );
+
+        let range = Range::new_from_range(Char::new('\u{4}')..=Char::new('\u{6}'));
+        let condition = Condition::from_range(&range, &from_spanning_set).unwrap();
+        assert_eq!(
+            range,
+            converter
+                .convert(&condition)
+                .unwrap()
+                .to_range(&to_spanning_set)
+                .unwrap()
+        );
+
+        let range = Range::new_from_ranges(&[
+            AnyRange::from(Char::new('\u{4}')..=Char::new('\u{6}')),
+            AnyRange::from(Char::new('\u{9}')..=Char::new('\u{9}')),
+        ]);
+        let condition = Condition::from_range(&range, &from_spanning_set).unwrap();
+        assert_eq!(
+            range,
+            converter
+                .convert(&condition)
+                .unwrap()
+                .to_range(&to_spanning_set)
+                .unwrap()
+        );
+
+        Ok(())
+    }
+}

src/fast_automaton/condition/fast_bit_vec/mod.rs

@@ -123,7 +123,7 @@ impl FastBitVec {
         (!0) >> ((64 - bits % 64) % 64)
     }
 
-    pub fn get_hot_bits(&self) -> Vec<bool> {
+    pub fn get_bits(&self) -> Vec<bool> {
         let mut hot_bits = Vec::with_capacity(self.n);
         for i in 0..self.n {
             hot_bits.push(self.get(i).unwrap());