X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=cyclegraph.cc;h=f8cbdda81054a3992aa0f507c1b1bb8499887c5e;hb=8d4a273698366b54612e40742ef6fb7bd63c7090;hp=4c6acfea0f14bf3389c8036537a20aacf55d5ffe;hpb=f912ca726174373393b4c293ae2e28e404beb76c;p=model-checker.git

diff --git a/cyclegraph.cc b/cyclegraph.cc
index 4c6acfe..f8cbdda 100644
--- a/cyclegraph.cc
+++ b/cyclegraph.cc
@@ -3,6 +3,7 @@
 #include "common.h"
 #include "promise.h"
 #include "model.h"
+#include "threads-model.h"
 
 /** Initializes a CycleGraph object. */
 CycleGraph::CycleGraph() :
@@ -38,8 +39,10 @@ void CycleGraph::putNode(const ModelAction *act, CycleNode *node)
  */
 void CycleGraph::putNode(const Promise *promise, CycleNode *node)
 {
-	const ModelAction *reader = promise->get_action();
-	readerToPromiseNode.put(reader, node);
+	promiseToNode.put(promise, node);
+#if SUPPORT_MOD_ORDER_DUMP
+	nodeList.push_back(node);
+#endif
 }
 
 /**
@@ -48,8 +51,16 @@ void CycleGraph::putNode(const Promise *promise, CycleNode *node)
  */
 void CycleGraph::erasePromiseNode(const Promise *promise)
 {
-	const ModelAction *reader = promise->get_action();
-	readerToPromiseNode.put(reader, NULL);
+	promiseToNode.put(promise, NULL);
+#if SUPPORT_MOD_ORDER_DUMP
+	/* Remove the promise node from nodeList */
+	CycleNode *node = getNode_noCreate(promise);
+	for (unsigned int i = 0; i < nodeList.size(); )
+		if (nodeList[i] == node)
+			nodeList.erase(nodeList.begin() + i);
+		else
+			i++;
+#endif
 }
 
 /** @return The corresponding CycleNode, if exists; otherwise NULL */
@@ -61,7 +72,7 @@ CycleNode * CycleGraph::getNode_noCreate(const ModelAction *act) const
 /** @return The corresponding CycleNode, if exists; otherwise NULL */
 CycleNode * CycleGraph::getNode_noCreate(const Promise *promise) const
 {
-	return readerToPromiseNode.get(promise->get_action());
+	return promiseToNode.get(promise);
 }
 
 /**
@@ -102,17 +113,22 @@ CycleNode * CycleGraph::getNode(const Promise *promise)
 }
 
 /**
- * @return false if the resolution results in a cycle; true otherwise
+ * Resolve/satisfy a Promise with a particular store ModelAction, taking care
+ * of the CycleGraph cleanups, including merging any necessary CycleNodes.
+ *
+ * @param promise The Promise to resolve
+ * @param writer The store that will resolve this Promise
+ * @return false if the resolution results in a cycle (or fails in some other
+ * way); true otherwise
  */
-bool CycleGraph::resolvePromise(ModelAction *reader, ModelAction *writer,
-		promise_list_t *mustResolve)
+bool CycleGraph::resolvePromise(const Promise *promise, ModelAction *writer)
 {
-	CycleNode *promise_node = readerToPromiseNode.get(reader);
+	CycleNode *promise_node = promiseToNode.get(promise);
 	CycleNode *w_node = actionToNode.get(writer);
 	ASSERT(promise_node);
 
 	if (w_node)
-		return mergeNodes(w_node, promise_node, mustResolve);
+		return mergeNodes(w_node, promise_node);
 	/* No existing write-node; just convert the promise-node */
 	promise_node->resolvePromise(writer);
 	erasePromiseNode(promise_node->getPromise());
@@ -128,63 +144,46 @@ bool CycleGraph::resolvePromise(ModelAction *reader, ModelAction *writer,
  * @param w_node The write ModelAction node with which to merge
  * @param p_node The Promise node to merge. Will be destroyed after this
  * function.
- * @param mustMerge Return (pass-by-reference) any additional Promises that
- * must also be merged with w_node
  *
- * @return false if the merge results in a cycle; true otherwise
+ * @return false if the merge cannot succeed; true otherwise
  */
-bool CycleGraph::mergeNodes(CycleNode *w_node, CycleNode *p_node,
-		promise_list_t *mustMerge)
+bool CycleGraph::mergeNodes(CycleNode *w_node, CycleNode *p_node)
 {
 	ASSERT(!w_node->is_promise());
 	ASSERT(p_node->is_promise());
 
 	const Promise *promise = p_node->getPromise();
-	if (!promise->is_compatible(w_node->getAction())) {
-		hasCycles = true;
+	if (!promise->is_compatible(w_node->getAction()) ||
+			!promise->same_value(w_node->getAction()))
 		return false;
-	}
 
 	/* Transfer the RMW */
 	CycleNode *promise_rmw = p_node->getRMW();
 	if (promise_rmw && promise_rmw != w_node->getRMW() && w_node->setRMW(promise_rmw))
-		hasCycles = true;
+		return false;
 
 	/* 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);
-			} else
-				addNodeEdge(back, w_node);
-		}
+		if (back == w_node)
+			continue;
+		addNodeEdge(back, w_node);
+		if (hasCycles)
+			return false;
 	}
 
 	/* 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);
-			} else
-				addNodeEdge(w_node, forward);
-		}
+		if (forward == w_node)
+			continue;
+		addNodeEdge(w_node, forward);
+		if (hasCycles)
+			return false;
 	}
 
 	erasePromiseNode(promise);
-	delete p_node;
+	/* Not deleting p_node, to maintain consistency if mergeNodes() fails */
 
 	return !hasCycles;
 }
@@ -294,26 +293,76 @@ bool CycleGraph::addEdge(const T *from, const U *to)
 
 	return addNodeEdge(fromnode, tonode);
 }
-/* Instantiate three forms of CycleGraph::addEdge */
+/* Instantiate four 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);
+template bool CycleGraph::addEdge(const Promise *from, const Promise *to);
 
 #if SUPPORT_MOD_ORDER_DUMP
+
+static void print_node(FILE *file, const CycleNode *node, int label)
+{
+	if (node->is_promise()) {
+		const Promise *promise = node->getPromise();
+		int idx = model->get_promise_number(promise);
+		fprintf(file, "P%u", idx);
+		if (label) {
+			int first = 1;
+			fprintf(file, " [label=\"P%d, T", idx);
+			for (unsigned int i = 0 ; i < model->get_num_threads(); i++)
+				if (promise->thread_is_available(int_to_id(i))) {
+					fprintf(file, "%s%u", first ? "": ",", i);
+					first = 0;
+				}
+			fprintf(file, "\"]");
+		}
+	} else {
+		const ModelAction *act = node->getAction();
+		modelclock_t idx = act->get_seq_number();
+		fprintf(file, "N%u", idx);
+		if (label)
+			fprintf(file, " [label=\"N%u, T%u\"]", idx, act->get_tid());
+	}
+}
+
+static void print_edge(FILE *file, const CycleNode *from, const CycleNode *to, const char *prop)
+{
+	print_node(file, from, 0);
+	fprintf(file, " -> ");
+	print_node(file, to, 0);
+	if (prop && strlen(prop))
+		fprintf(file, " [%s]", prop);
+	fprintf(file, ";\n");
+}
+
+void CycleGraph::dot_print_node(FILE *file, const ModelAction *act)
+{
+	print_node(file, getNode(act), 1);
+}
+
+template <typename T, typename U>
+void CycleGraph::dot_print_edge(FILE *file, const T *from, const U *to, const char *prop)
+{
+	CycleNode *fromnode = getNode(from);
+	CycleNode *tonode = getNode(to);
+
+	print_edge(file, fromnode, tonode, prop);
+}
+/* Instantiate two forms of CycleGraph::dot_print_edge */
+template void CycleGraph::dot_print_edge(FILE *file, const Promise *from, const ModelAction *to, const char *prop);
+template void CycleGraph::dot_print_edge(FILE *file, const ModelAction *from, const ModelAction *to, const char *prop);
+
 void CycleGraph::dumpNodes(FILE *file) const
 {
 	for (unsigned int i = 0; i < nodeList.size(); i++) {
-		CycleNode *cn = nodeList[i];
-		const ModelAction *action = cn->getAction();
-		fprintf(file, "N%u [label=\"%u, T%u\"];\n", action->get_seq_number(), action->get_seq_number(), action->get_tid());
-		if (cn->getRMW() != NULL) {
-			fprintf(file, "N%u -> N%u[style=dotted];\n", action->get_seq_number(), cn->getRMW()->getAction()->get_seq_number());
-		}
-		for (unsigned int j = 0; j < cn->getNumEdges(); j++) {
-			CycleNode *dst = cn->getEdge(j);
-			const ModelAction *dstaction = dst->getAction();
-			fprintf(file, "N%u -> N%u;\n", action->get_seq_number(), dstaction->get_seq_number());
-		}
+		CycleNode *n = nodeList[i];
+		print_node(file, n, 1);
+		fprintf(file, ";\n");
+		if (n->getRMW())
+			print_edge(file, n, n->getRMW(), "style=dotted");
+		for (unsigned int j = 0; j < n->getNumEdges(); j++)
+			print_edge(file, n, n->getEdge(j), NULL);
 	}
 }
 
@@ -360,13 +409,13 @@ bool CycleGraph::checkReachable(const CycleNode *from, const CycleNode *to) cons
 }
 
 /**
- * Checks whether one ModelAction can reach another ModelAction/Promise
- * @param from The ModelAction from which to begin exploration
+ * Checks whether one ModelAction/Promise can reach another ModelAction/Promise
+ * @param from The ModelAction or Promise 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
+template <typename T, typename U>
+bool CycleGraph::checkReachable(const T *from, const U *to) const
 {
 	CycleNode *fromnode = getNode_noCreate(from);
 	CycleNode *tonode = getNode_noCreate(to);
@@ -376,11 +425,13 @@ bool CycleGraph::checkReachable(const ModelAction *from, const T *to) const
 
 	return checkReachable(fromnode, tonode);
 }
-/* Instantiate two forms of CycleGraph::checkReachable */
+/* Instantiate three 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;
+template bool CycleGraph::checkReachable(const Promise *from,
+		const ModelAction *to) const;
 
 /** @return True, if the promise has failed; false otherwise */
 bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) const
@@ -395,6 +446,8 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) cons
 		CycleNode *node = queue.back();
 		queue.pop_back();
 
+		if (node->getPromise() == promise)
+			return true;
 		if (!node->is_promise() &&
 				promise->eliminate_thread(node->getAction()->get_tid()))
 			return true;