X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=cyclegraph.cc;h=69d6660bccee0768d2f8629d8ca787e6b3912d22;hp=3bb5ab84a88c240d11ee5b7ae1ed01d2ab7c7207;hb=24d17393dc45f60f6f6660159f2f329d1cc5d15a;hpb=4da2859902f1096053a2d9857df502d3bb94e6e4

diff --git a/cyclegraph.cc b/cyclegraph.cc
index 3bb5ab84..69d6660b 100644
--- a/cyclegraph.cc
+++ b/cyclegraph.cc
@@ -31,6 +31,39 @@ 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);
+#if SUPPORT_MOD_ORDER_DUMP
+	nodeList.push_back(node);
+#endif
+}
+
+/**
+ * @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);
+#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 */
 CycleNode * CycleGraph::getNode_noCreate(const ModelAction *act) const
 {
@@ -72,11 +105,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 +127,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;
 }
@@ -118,47 +150,54 @@ 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;
 		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);
+		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;
@@ -168,13 +207,16 @@ bool CycleGraph::mergeNodes(CycleNode *w_node, CycleNode *p_node,
  * Adds an edge between two CycleNodes.
  * @param fromnode The edge comes from this CycleNode
  * @param tonode The edge points to this CycleNode
+ * @return True, if new edge(s) are added; otherwise false
  */
-void CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode)
+bool CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode)
 {
+	bool added;
+
 	if (!hasCycles)
 		hasCycles = checkReachable(tonode, fromnode);
 
-	if (fromnode->addEdge(tonode))
+	if ((added = fromnode->addEdge(tonode)))
 		rollbackvector.push_back(fromnode);
 
 	/*
@@ -186,24 +228,28 @@ void CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode)
 		if (!hasCycles)
 			hasCycles = checkReachable(tonode, rmwnode);
 
-		if (rmwnode->addEdge(tonode))
+		if (rmwnode->addEdge(tonode)) {
 			rollbackvector.push_back(rmwnode);
+			added = true;
+		}
 	}
+	return added;
 }
 
 /**
  * @brief Add an edge between a write and the RMW which reads from it
  *
  * Handles special case of a RMW action, where the ModelAction rmw reads from
- * the ModelAction from. The key differences are:
+ * the ModelAction/Promise from. The key differences are:
  * (1) no write can occur in between the rmw and the from action.
  * (2) Only one RMW action can read from a given write.
  *
- * @param from The edge comes from this ModelAction
+ * @param from The edge comes from this ModelAction/Promise
  * @param rmw The edge points to this ModelAction; this action must read from
- * ModelAction from
+ * the ModelAction/Promise from
  */
-void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw)
+template <typename T>
+void CycleGraph::addRMWEdge(const T *from, const ModelAction *rmw)
 {
 	ASSERT(from);
 	ASSERT(rmw);
@@ -234,21 +280,84 @@ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw)
 
 	addNodeEdge(fromnode, rmwnode);
 }
+/* Instantiate two forms of CycleGraph::addRMWEdge */
+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
+
+static void print_node(const CycleNode *node, FILE *file, int label)
+{
+	modelclock_t idx;
+	if (node->is_promise()) {
+		const Promise *promise = node->getPromise();
+		idx = promise->get_action()->get_seq_number();
+		fprintf(file, "P%u", idx);
+		if (label) {
+			int first = 1;
+			fprintf(file, " [label=\"P%u, 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();
+		idx = act->get_seq_number();
+		fprintf(file, "N%u", idx);
+		if (label)
+			fprintf(file, " [label=\"N%u, T%u\"]", idx, act->get_tid());
+	}
+}
+
 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());
+		CycleNode *n = nodeList[i];
+		print_node(n, file, 1);
+		fprintf(file, ";\n");
+		if (n->getRMW() != NULL) {
+			print_node(n, file, 0);
+			fprintf(file, " -> ");
+			print_node(n->getRMW(), file, 0);
+			fprintf(file, "[style=dotted];\n");
 		}
-		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());
+		for (unsigned int j = 0; j < n->getNumEdges(); j++) {
+			print_node(n, file, 0);
+			fprintf(file, " -> ");
+			print_node(n->getEdge(j), file, 0);
+			fprintf(file, ";\n");
 		}
 	}
 }
@@ -295,6 +404,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
 {
@@ -342,7 +474,7 @@ void CycleGraph::commitChanges()
 void CycleGraph::rollbackChanges()
 {
 	for (unsigned int i = 0; i < rollbackvector.size(); i++)
-		rollbackvector[i]->popEdge();
+		rollbackvector[i]->removeEdge();
 
 	for (unsigned int i = 0; i < rmwrollbackvector.size(); i++)
 		rmwrollbackvector[i]->clearRMW();