improved cycle detection efficiency

Author: MarcG-TUE

include/maxplus/base/fsm/fsm.h

@@ -210,6 +210,7 @@ class FiniteStateMachine {
     [[nodiscard]] virtual const SetOfStateRefs &getInitialStates() const = 0;
     [[nodiscard]] virtual const SetOfStateRefs &getFinalStates() const = 0;
     [[nodiscard]] virtual const SetOfStates &getStates() const = 0;
+    [[nodiscard]] virtual SetOfStateRefs getStateRefs() const = 0;
     [[nodiscard]] virtual const SetOfEdges &getEdges() const = 0;
 };
 
@@ -266,19 +267,29 @@ class DepthFirstSearch {
 
     virtual void onSimpleCycle(DfsStack &stack){};
 
-    explicit DepthFirstSearch(const FiniteStateMachine &targetFsm) : fsm(targetFsm){};
+    const FiniteStateMachine& getFSM(){
+        return this->fsm;
+    }
+
+    explicit DepthFirstSearch(const FiniteStateMachine &targetFsm) :
+        fsm(targetFsm)
+    {};
 
     // Execute the depth first search
-    void DoDepthFirstSearch(const StateRef &startingState, bool fullDFS = false) {
+    void DoDepthFirstSearch(const SetOfStateRefs &startingStates, bool fullDFS = false) {
         // store visited states
         SetOfStateRefs visitedStates;
         SetOfStateRefs statesOnStack;
 
+        this->_abort = false;
+
         // put initial state on the stack
-        dfsStack.emplace_back(startingState);
-        this->onEnterState(startingState);
+        for (const auto& s: startingStates) {
+            dfsStack.emplace_back(s);
+            this->onEnterState(s);
+        }
 
-        while (!(dfsStack.empty())) {
+        while (!this->_abort && !(dfsStack.empty())) {
             DFSStackItem &si = dfsStack.back();
 
             // current item complete?
@@ -313,21 +324,34 @@ class DepthFirstSearch {
         }
     }
 
+    void DoDepthFirstSearch(const StateRef &startingState, bool fullDFS = false){
+        SetOfStateRefs stateSet;
+        stateSet.insert(startingState);
+        return this->DoDepthFirstSearch(stateSet, fullDFS);
+    }
+
     // Execute the depth first search
     void DoDepthFirstSearch(bool fullDFS = false) {
-        this->DoDepthFirstSearch(this->fsm.getInitialState(), fullDFS);
+        this->DoDepthFirstSearch(this->fsm.getInitialStates(), fullDFS);
     }
 
-protected:
+    void abortDFS() {
+        this->_abort = true;
+    }
+
+private:
     const FiniteStateMachine &fsm;
+    bool _abort{};
+
 };
 
 // Check for cycles
 class DetectCycle : public DepthFirstSearch {
 public:
     bool hasCycle = false;
 
-    explicit DetectCycle(const FiniteStateMachine &targetFsm) : DepthFirstSearch(targetFsm){};
+    explicit DetectCycle(const FiniteStateMachine &targetFsm) : DepthFirstSearch(targetFsm){
+    };
 
     ~DetectCycle() override = default;
 
@@ -339,30 +363,15 @@ class DetectCycle : public DepthFirstSearch {
     bool checkForCycles() { return this->checkForCycles(nullptr); }
 
     bool checkForCycles(ListOfStateRefs *cycle) {
-        this->visitedStates.clear();
         this->cycle = cycle;
-        const SetOfStates &states = this->fsm.getStates();
-        auto nextStartingState = states.begin();
-        while (nextStartingState != states.end()) {
-            this->DoDepthFirstSearch((*nextStartingState).second->getReference());
-            if (this->hasCycle) {
-                return true;
-            }
-            while (nextStartingState != states.end()
-                   && this->visitedStates.includesState(
-                           (*nextStartingState).second->getReference())) {
-                nextStartingState++;
-            }
-        }
-        return false;
+        const SetOfStateRefs states = this->getFSM().getStateRefs();
+        this->DoDepthFirstSearch(states);
+        return this->hasCycle;
     }
 
 private:
-    SetOfStateRefs visitedStates;
     ListOfStateRefs *cycle = nullptr;
 
-    void onEnterState(StateRef s) override { this->visitedStates.insert(s); }
-
     void onSimpleCycle(DfsStack &stack) override {
         if (!this->hasCycle) {
             if (this->cycle != nullptr) {
@@ -371,6 +380,7 @@ class DetectCycle : public DepthFirstSearch {
                 }
             }
             this->hasCycle = true;
+            this->abortDFS();
         }
     }
 };
@@ -657,6 +667,14 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
         return this->states;
     };
 
+    [[nodiscard]] FSM::Abstract::SetOfStateRefs getStateRefs() const override {
+        FSM::Abstract::SetOfStateRefs result;
+        for (const auto& s: this->states) {
+            result.insert(s.second->getReference());
+        }
+        return result;
+    };
+
     [[nodiscard]] const SetOfEdges<StateLabelType, EdgeLabelType> &getEdges() const override {
         return this->edges;
     };