cyclegraph: refactor for indentation

[model-checker.git] / cyclegraph.cc

diff --git a/cyclegraph.cc b/cyclegraph.cc
index 1ff9d70b792ad685749f8fa3c038bc7de91fdb86..b13837293c665e9eacc4a4440e91631770c22347 100644 (file)
--- a/cyclegraph.cc
+++ b/cyclegraph.cc
@@ -31,6 +31,27 @@ void CycleGraph::putNode(const ModelAction *act, CycleNode *node)
 #endif
 }
 
+/**
+ * Add a CycleNode to the graph, corresponding to a Promise
+ * @param promise The Promise that should be added
+ * @param node The CycleNode that corresponds to the Promise
+ */
+void CycleGraph::putNode(const Promise *promise, CycleNode *node)
+{
+       const ModelAction *reader = promise->get_action();
+       readerToPromiseNode.put(reader, node);
+}
+
+/**
+ * @brief Remove the Promise node from the graph
+ * @param promise The promise to remove from the graph
+ */
+void CycleGraph::erasePromiseNode(const Promise *promise)
+{
+       const ModelAction *reader = promise->get_action();
+       readerToPromiseNode.put(reader, NULL);
+}
+
 /** @return The corresponding CycleNode, if exists; otherwise NULL */
 CycleNode * CycleGraph::getNode_noCreate(const ModelAction *act) const
 {
@@ -72,11 +93,10 @@ CycleNode * CycleGraph::getNode(const ModelAction *action)
  */
 CycleNode * CycleGraph::getNode(const Promise *promise)
 {
-       const ModelAction *reader = promise->get_action();
        CycleNode *node = getNode_noCreate(promise);
        if (node == NULL) {
                node = new CycleNode(promise);
-               readerToPromiseNode.put(reader, node);
+               putNode(promise, node);
        }
        return node;
 }
@@ -95,7 +115,7 @@ bool CycleGraph::resolvePromise(ModelAction *reader, ModelAction *writer,
                return mergeNodes(w_node, promise_node, mustResolve);
        /* No existing write-node; just convert the promise-node */
        promise_node->resolvePromise(writer);
-       readerToPromiseNode.put(reader, NULL); /* erase promise_node */
+       erasePromiseNode(promise_node->getPromise());
        putNode(writer, promise_node);
        return true;
 }
@@ -133,38 +153,37 @@ bool CycleGraph::mergeNodes(CycleNode *w_node, CycleNode *p_node,
        /* Transfer back edges to w_node */
        while (p_node->getNumBackEdges() > 0) {
                CycleNode *back = p_node->removeBackEdge();
-               if (back != w_node) {
-                       if (back->is_promise()) {
-                               if (checkReachable(w_node, back)) {
-                                       /* Edge would create cycle; merge instead */
-                                       mustMerge->push_back(back->getPromise());
-                                       if (!mergeNodes(w_node, back, mustMerge))
-                                               return false;
-                               } else
-                                       back->addEdge(w_node);
+               if (back == w_node)
+                       continue;
+               if (back->is_promise()) {
+                       if (checkReachable(w_node, back)) {
+                               /* Edge would create cycle; merge instead */
+                               mustMerge->push_back(back->getPromise());
+                               if (!mergeNodes(w_node, back, mustMerge))
+                                       return false;
                        } else
-                               addNodeEdge(back, w_node);
-               }
+                               back->addEdge(w_node);
+               } else
+                       addNodeEdge(back, w_node);
        }
 
        /* Transfer forward edges to w_node */
        while (p_node->getNumEdges() > 0) {
                CycleNode *forward = p_node->removeEdge();
-               if (forward != w_node) {
-                       if (forward->is_promise()) {
-                               if (checkReachable(forward, w_node)) {
-                                       mustMerge->push_back(forward->getPromise());
-                                       if (!mergeNodes(w_node, forward, mustMerge))
-                                               return false;
-                               } else
-                                       w_node->addEdge(forward);
+               if (forward == w_node)
+                       continue;
+               if (forward->is_promise()) {
+                       if (checkReachable(forward, w_node)) {
+                               mustMerge->push_back(forward->getPromise());
+                               if (!mergeNodes(w_node, forward, mustMerge))
+                                       return false;
                        } else
-                               addNodeEdge(w_node, forward);
-               }
+                               w_node->addEdge(forward);
+               } else
+                       addNodeEdge(w_node, forward);
        }
 
-       /* erase p_node */
-       readerToPromiseNode.put(promise->get_action(), NULL);
+       erasePromiseNode(promise);
        delete p_node;
 
        return !hasCycles;
@@ -251,6 +270,35 @@ void CycleGraph::addRMWEdge(const T *from, const ModelAction *rmw)
 template void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw);
 template void CycleGraph::addRMWEdge(const Promise *from, const ModelAction *rmw);
 
+/**
+ * @brief Adds an edge between objects
+ *
+ * This function will add an edge between any two objects which can be
+ * associated with a CycleNode. That is, if they have a CycleGraph::getNode
+ * implementation.
+ *
+ * The object to is ordered after the object from.
+ *
+ * @param to The edge points to this object, of type T
+ * @param from The edge comes from this object, of type U
+ * @return True, if new edge(s) are added; otherwise false
+ */
+template <typename T, typename U>
+bool CycleGraph::addEdge(const T *from, const U *to)
+{
+       ASSERT(from);
+       ASSERT(to);
+
+       CycleNode *fromnode = getNode(from);
+       CycleNode *tonode = getNode(to);
+
+       return addNodeEdge(fromnode, tonode);
+}
+/* Instantiate three forms of CycleGraph::addEdge */
+template bool CycleGraph::addEdge(const ModelAction *from, const ModelAction *to);
+template bool CycleGraph::addEdge(const ModelAction *from, const Promise *to);
+template bool CycleGraph::addEdge(const Promise *from, const ModelAction *to);
+
 #if SUPPORT_MOD_ORDER_DUMP
 void CycleGraph::dumpNodes(FILE *file) const
 {
@@ -311,6 +359,29 @@ bool CycleGraph::checkReachable(const CycleNode *from, const CycleNode *to) cons
        return false;
 }
 
+/**
+ * Checks whether one ModelAction can reach another ModelAction/Promise
+ * @param from The ModelAction from which to begin exploration
+ * @param to The ModelAction or Promise to reach
+ * @return True, @a from can reach @a to; otherwise, false
+ */
+template <typename T>
+bool CycleGraph::checkReachable(const ModelAction *from, const T *to) const
+{
+       CycleNode *fromnode = getNode_noCreate(from);
+       CycleNode *tonode = getNode_noCreate(to);
+
+       if (!fromnode || !tonode)
+               return false;
+
+       return checkReachable(fromnode, tonode);
+}
+/* Instantiate two forms of CycleGraph::checkReachable */
+template bool CycleGraph::checkReachable(const ModelAction *from,
+               const ModelAction *to) const;
+template bool CycleGraph::checkReachable(const ModelAction *from,
+               const Promise *to) const;
+
 /** @return True, if the promise has failed; false otherwise */
 bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) const
 {