X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=cyclegraph.cc;h=7fadcbda00d8b6f02f9cfe81d5cd3f423e9a3a2b;hp=54b91238d98b2d22155a45a838da9a3b655d376c;hb=5236e7a4403ccc6d28b3fdc746c5710d6190310a;hpb=776fc7207dec4959b4fa3e4bd7cb71cc38a19353 diff --git a/cyclegraph.cc b/cyclegraph.cc index 54b91238..7fadcbda 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -31,14 +31,62 @@ 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 +{ + return actionToNode.get(act); +} + +/** @return The corresponding CycleNode, if exists; otherwise NULL */ +CycleNode * CycleGraph::getNode_noCreate(const Promise *promise) const +{ + return readerToPromiseNode.get(promise->get_action()); +} + /** * @brief Returns the CycleNode corresponding to a given ModelAction + * + * Gets (or creates, if none exist) a CycleNode corresponding to a ModelAction + * * @param action The ModelAction to find a node for * @return The CycleNode paired with this action */ CycleNode * CycleGraph::getNode(const ModelAction *action) { - CycleNode *node = actionToNode.get(action); + CycleNode *node = getNode_noCreate(action); if (node == NULL) { node = new CycleNode(action); putNode(action, node); @@ -57,39 +105,14 @@ CycleNode * CycleGraph::getNode(const ModelAction *action) */ CycleNode * CycleGraph::getNode(const Promise *promise) { - const ModelAction *reader = promise->get_action(); - CycleNode *node = readerToPromiseNode.get(reader); + CycleNode *node = getNode_noCreate(promise); if (node == NULL) { node = new CycleNode(promise); - readerToPromiseNode.put(reader, node); + putNode(promise, node); } return node; } -/* - * @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 - */ -template -void CycleGraph::addEdge(const T from, const U to) -{ - ASSERT(from); - ASSERT(to); - - CycleNode *fromnode = getNode(from); - CycleNode *tonode = getNode(to); - - addNodeEdge(fromnode, tonode); -} - /** * @return false if the resolution results in a cycle; true otherwise */ @@ -104,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; } @@ -127,48 +150,55 @@ 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); - delete p_node; + erasePromiseNode(promise); + /* Not deleting p_node, to maintain consistency if mergeNodes() fails */ return !hasCycles; } @@ -177,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); /* @@ -195,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 +void CycleGraph::addRMWEdge(const T *from, const ModelAction *rmw) { ASSERT(from); ASSERT(rmw); @@ -243,21 +280,85 @@ 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 +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 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"); } } } @@ -274,24 +375,6 @@ void CycleGraph::dumpGraphToFile(const char *filename) const } #endif -/** - * 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 -bool CycleGraph::checkReachable(const ModelAction *from, const T *to) const -{ - CycleNode *fromnode = actionToNode.get(from); - CycleNode *tonode = actionToNode.get(to); - - if (!fromnode || !tonode) - return false; - - return checkReachable(fromnode, tonode); -} - /** * Checks whether one CycleNode can reach another. * @param from The CycleNode from which to begin exploration @@ -322,6 +405,32 @@ bool CycleGraph::checkReachable(const CycleNode *from, const CycleNode *to) cons return false; } +/** + * 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 T *from, const U *to) const +{ + CycleNode *fromnode = getNode_noCreate(from); + CycleNode *tonode = getNode_noCreate(to); + + if (!fromnode || !tonode) + return false; + + return checkReachable(fromnode, tonode); +} +/* 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 { std::vector< CycleNode *, ModelAlloc > queue; @@ -334,9 +443,9 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) cons CycleNode *node = queue.back(); queue.pop_back(); - if (promise->eliminate_thread(node->getAction()->get_tid())) { + if (!node->is_promise() && + promise->eliminate_thread(node->getAction()->get_tid())) return true; - } for (unsigned int i = 0; i < node->getNumEdges(); i++) { CycleNode *next = node->getEdge(i); @@ -368,7 +477,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();