{
const ModelAction *reader = promise->get_action();
readerToPromiseNode.put(reader, node);
+#if SUPPORT_MOD_ORDER_DUMP
+ nodeList.push_back(node);
+#endif
}
/**
{
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 */
/* Transfer the RMW */
CycleNode *promise_rmw = p_node->getRMW();
- if (promise_rmw && promise_rmw != w_node->getRMW() && w_node->setRMW(promise_rmw))
+ 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);
}
erasePromiseNode(promise);
- delete p_node;
+ /* Not deleting p_node, to maintain consistency if mergeNodes() fails */
return !hasCycles;
}
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(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");
}
}
}
}
/**
- * 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);
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
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;