cyclegraph: separate an 'addEdge(CycleNode *, CycleNode *) function

[model-checker.git] / cyclegraph.cc

diff --git a/cyclegraph.cc b/cyclegraph.cc
index ec0ce45f55ae65ae77325889b0aa0bfe84444cf8..62cef7c56079e2d2a46587a181340320a9fe0405 100644 (file)
--- a/cyclegraph.cc
+++ b/cyclegraph.cc
@@ -62,26 +62,30 @@ void CycleGraph::addEdge(const ModelAction *from, const ModelAction *to)
        CycleNode *fromnode = getNode(from);
        CycleNode *tonode = getNode(to);
 
+       addEdge(fromnode, tonode);
+}
+
+/**
+ * Adds an edge between two CycleNodes.
+ * @param fromnode The edge comes from this CycleNode
+ * @param tonode The edge points to this CycleNode
+ */
+void CycleGraph::addEdge(CycleNode *fromnode, CycleNode *tonode)
+{
        if (!hasCycles)
-               hasCycles = edgeCreatesCycle(fromnode, tonode);
+               hasCycles = checkReachable(tonode, fromnode);
 
        if (fromnode->addEdge(tonode))
                rollbackvector.push_back(fromnode);
 
-
-       CycleNode *rmwnode = fromnode->getRMW();
-
        /*
         * If the fromnode has a rmwnode that is not the tonode, we should add
         * an edge between its rmwnode and the tonode
-        *
-        * If tonode is also a rmw, don't do this check as the execution is
-        * doomed and we'll catch the problem elsewhere, but we want to allow
-        * for the possibility of sending to's write value to rmwnode
         */
-       if (rmwnode != NULL && !to->is_rmw()) {
+       CycleNode *rmwnode = fromnode->getRMW();
+       if (rmwnode && rmwnode != tonode) {
                if (!hasCycles)
-                       hasCycles = edgeCreatesCycle(rmwnode, tonode);
+                       hasCycles = checkReachable(tonode, rmwnode);
 
                if (rmwnode->addEdge(tonode))
                        rollbackvector.push_back(rmwnode);
@@ -123,11 +127,7 @@ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw)
                }
        }
 
-       if (!hasCycles)
-               hasCycles = edgeCreatesCycle(fromnode, rmwnode);
-
-       if (fromnode->addEdge(rmwnode))
-               rollbackvector.push_back(fromnode);
+       addEdge(fromnode, rmwnode);
 }
 
 #if SUPPORT_MOD_ORDER_DUMP
@@ -160,18 +160,6 @@ void CycleGraph::dumpGraphToFile(const char *filename) const
 }
 #endif
 
-/**
- * Checks whether the addition of an edge between these two nodes would create
- * a cycle in the graph.
- * @param from The CycleNode from which the edge would start
- * @param to The CycleNode to which the edge would point
- * @return True if this edge would create a cycle; false otherwise
- */
-bool CycleGraph::edgeCreatesCycle(const CycleNode *from, const CycleNode *to) const
-{
-       return (from == to) || checkReachable(to, from);
-}
-
 /**
  * Checks whether one ModelAction can reach another.
  * @param from The ModelAction from which to begin exploration
@@ -231,7 +219,7 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) cons
                CycleNode *node = queue.back();
                queue.pop_back();
 
-               if (promise->increment_threads(node->getAction()->get_tid())) {
+               if (promise->eliminate_thread(node->getAction()->get_tid())) {
                        return true;
                }
 
@@ -329,6 +317,7 @@ unsigned int CycleNode::getNumBackEdges() const
 /**
  * Adds an edge from this CycleNode to another CycleNode.
  * @param node The node to which we add a directed edge
+ * @return True if this edge is a new edge; false otherwise
  */
 bool CycleNode::addEdge(CycleNode *node)
 {