X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=cyclegraph.cc;h=8d37dea8b9fc6ea6770528e57238df13d2b5a323;hp=8f095dc580afa72ab0f48756b29df97e092d6749;hb=5ea8e3d5d861ed363e5ac5f3b20b8181dd197efb;hpb=fbacb5f41ada96e7b539ccc41deccb1a7e1a1ba8 diff --git a/cyclegraph.cc b/cyclegraph.cc index 8f095dc5..8d37dea8 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -3,10 +3,12 @@ #include "common.h" #include "promise.h" #include "model.h" +#include "threads-model.h" /** Initializes a CycleGraph object. */ CycleGraph::CycleGraph() : discovered(new HashTable(16)), + queue(new ModelVector()), hasCycles(false), oldCycles(false) { @@ -15,6 +17,7 @@ CycleGraph::CycleGraph() : /** CycleGraph destructor */ CycleGraph::~CycleGraph() { + delete queue; delete discovered; } @@ -31,6 +34,37 @@ 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) +{ + promiseToNode.put(promise, 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) +{ + 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 */ CycleNode * CycleGraph::getNode_noCreate(const ModelAction *act) const { @@ -40,7 +74,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); } /** @@ -72,30 +106,34 @@ 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; } /** - * @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); - readerToPromiseNode.put(reader, NULL); /* erase promise_node */ + erasePromiseNode(promise_node->getPromise()); putNode(writer, promise_node); return true; } @@ -108,64 +146,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; } - /* erase p_node */ - readerToPromiseNode.put(promise->get_action(), NULL); - delete p_node; + erasePromiseNode(promise); + /* Not deleting p_node, to maintain consistency if mergeNodes() fails */ return !hasCycles; } @@ -180,11 +200,11 @@ bool CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode) { bool added; - if (!hasCycles) - hasCycles = checkReachable(tonode, fromnode); - - if ((added = fromnode->addEdge(tonode))) + if ((added = fromnode->addEdge(tonode))) { rollbackvector.push_back(fromnode); + if (!hasCycles) + hasCycles = checkReachable(tonode, fromnode); + } /* * If the fromnode has a rmwnode that is not the tonode, we should add @@ -192,10 +212,10 @@ bool CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode) */ CycleNode *rmwnode = fromnode->getRMW(); if (rmwnode && rmwnode != tonode) { - if (!hasCycles) - hasCycles = checkReachable(tonode, rmwnode); - if (rmwnode->addEdge(tonode)) { + if (!hasCycles) + hasCycles = checkReachable(tonode, rmwnode); + rollbackvector.push_back(rmwnode); added = true; } @@ -275,26 +295,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 +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); } } @@ -318,22 +388,20 @@ void CycleGraph::dumpGraphToFile(const char *filename) const */ bool CycleGraph::checkReachable(const CycleNode *from, const CycleNode *to) const { - std::vector< const CycleNode *, ModelAlloc > queue; discovered->reset(); - - queue.push_back(from); + queue->clear(); + queue->push_back(from); discovered->put(from, from); - while (!queue.empty()) { - const CycleNode *node = queue.back(); - queue.pop_back(); + while (!queue->empty()) { + const CycleNode *node = queue->back(); + queue->pop_back(); if (node == to) return true; - for (unsigned int i = 0; i < node->getNumEdges(); i++) { CycleNode *next = node->getEdge(i); if (!discovered->contains(next)) { discovered->put(next, next); - queue.push_back(next); + queue->push_back(next); } } } @@ -341,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 -bool CycleGraph::checkReachable(const ModelAction *from, const T *to) const +template +bool CycleGraph::checkReachable(const T *from, const U *to) const { CycleNode *fromnode = getNode_noCreate(from); CycleNode *tonode = getNode_noCreate(to); @@ -357,25 +425,31 @@ bool CycleGraph::checkReachable(const ModelAction *from, const T *to) const return checkReachable(fromnode, tonode); } -/* Instantiate two forms of CycleGraph::checkReachable */ +/* Instantiate four 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; +template bool CycleGraph::checkReachable(const Promise *from, + const Promise *to) const; /** @return True, if the promise has failed; false otherwise */ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) const { - std::vector< CycleNode *, ModelAlloc > queue; discovered->reset(); + queue->clear(); CycleNode *from = actionToNode.get(fromact); - queue.push_back(from); + queue->push_back(from); discovered->put(from, from); - while (!queue.empty()) { - CycleNode *node = queue.back(); - queue.pop_back(); + while (!queue->empty()) { + 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; @@ -384,7 +458,7 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) cons CycleNode *next = node->getEdge(i); if (!discovered->contains(next)) { discovered->put(next, next); - queue.push_back(next); + queue->push_back(next); } } } @@ -480,7 +554,7 @@ unsigned int CycleNode::getNumBackEdges() const * @return True if the element was found; false otherwise */ template -static bool vector_remove_node(std::vector >& v, const T n) +static bool vector_remove_node(SnapVector& v, const T n) { for (unsigned int i = 0; i < v.size(); i++) { if (v[i] == n) {