X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=cyclegraph.cc;h=f4590bfb6fa1cd44b41efdd91157ddcdfa812d78;hb=89ecd60fab0d93d6df6aa35e663ab67db860fa1d;hp=66f9f69548608d02baa36dbd09bbd9b8ac2feac7;hpb=dd1028f1a33deab855739112b3fc78663524455e;p=c11tester.git diff --git a/cyclegraph.cc b/cyclegraph.cc index 66f9f695..f4590bfb 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -1,22 +1,21 @@ #include "cyclegraph.h" #include "action.h" #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), - hasRMWViolation(false), - oldRMWViolation(false) + oldCycles(false) { } /** CycleGraph destructor */ CycleGraph::~CycleGraph() { + delete queue; delete discovered; } @@ -33,14 +32,23 @@ void CycleGraph::putNode(const ModelAction *act, CycleNode *node) #endif } +/** @return The corresponding CycleNode, if exists; otherwise NULL */ +CycleNode * CycleGraph::getNode_noCreate(const ModelAction *act) const +{ + return actionToNode.get(act); +} + /** * @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); @@ -49,45 +57,56 @@ CycleNode * CycleGraph::getNode(const ModelAction *action) } /** - * Adds an edge between two ModelActions. The ModelAction @a to is ordered - * after the ModelAction @a from. - * @param to The edge points to this ModelAction - * @param from The edge comes from this ModelAction + * 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::addEdge(const ModelAction *from, const ModelAction *to) +bool CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode) { - ASSERT(from); - ASSERT(to); - - CycleNode *fromnode = getNode(from); - CycleNode *tonode = getNode(to); - - if (!hasCycles) - hasCycles = checkReachable(tonode, fromnode); - - if (fromnode->addEdge(tonode)) + if (fromnode->addEdge(tonode)) { rollbackvector.push_back(fromnode); + if (!hasCycles) + hasCycles = checkReachable(tonode, fromnode); + } else + return false; /* No new edge */ /* - * If the fromnode has a rmwnode that is not the tonode, we should add - * an edge between its rmwnode and the tonode + * If the fromnode has a rmwnode that is not the tonode, we should + * follow its RMW chain to add an edge at the end, unless we encounter + * tonode along the way */ CycleNode *rmwnode = fromnode->getRMW(); - if (rmwnode && rmwnode != tonode) { - if (!hasCycles) - hasCycles = checkReachable(tonode, rmwnode); + if (rmwnode) { + while (rmwnode != tonode && rmwnode->getRMW()) + rmwnode = rmwnode->getRMW(); + + if (rmwnode != tonode) { + if (rmwnode->addEdge(tonode)) { + if (!hasCycles) + hasCycles = checkReachable(tonode, rmwnode); - if (rmwnode->addEdge(tonode)) - rollbackvector.push_back(rmwnode); + rollbackvector.push_back(rmwnode); + } + } } + return true; } -/** Handles special case of a RMW action. The ModelAction rmw reads - * from the ModelAction from. The key differences are: (1) no write - * can occur in between the rmw and the from action. Only one RMW - * action can read from a given write. +/** + * @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/Promise from. The key differences are: + * -# No write can occur in between the @a rmw and @a from actions. + * -# Only one RMW action can read from a given write. + * + * @param from The edge comes from this ModelAction/Promise + * @param rmw The edge points to this ModelAction; this action must read 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); @@ -95,12 +114,14 @@ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) CycleNode *fromnode = getNode(from); CycleNode *rmwnode = getNode(rmw); + /* We assume that this RMW has no RMW reading from it yet */ + ASSERT(!rmwnode->getRMW()); + /* Two RMW actions cannot read from the same write. */ - if (fromnode->setRMW(rmwnode)) { - hasRMWViolation = true; - } else { + if (fromnode->setRMW(rmwnode)) + hasCycles = true; + else rmwrollbackvector.push_back(fromnode); - } /* Transfer all outgoing edges from the from node to the rmw node */ /* This process should not add a cycle because either: @@ -109,7 +130,7 @@ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) * (2) the fromnode is the new node and therefore it should not * have any outgoing edges. */ - for (unsigned int i = 0; i < fromnode->getNumEdges(); i++) { + for (unsigned int i = 0;i < fromnode->getNumEdges();i++) { CycleNode *tonode = fromnode->getEdge(i); if (tonode != rmwnode) { if (rmwnode->addEdge(tonode)) @@ -117,28 +138,85 @@ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) } } - if (!hasCycles) - hasCycles = checkReachable(rmwnode, fromnode); + addNodeEdge(fromnode, rmwnode); +} +/* Instantiate two forms of CycleGraph::addRMWEdge */ +template void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw); - if (fromnode->addEdge(rmwnode)) - rollbackvector.push_back(fromnode); +/** + * @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); #if SUPPORT_MOD_ORDER_DUMP + +static void print_node(FILE *file, const CycleNode *node, int label) +{ + 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 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()); - } + for (unsigned int i = 0;i < nodeList.size();i++) { + 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); } } @@ -154,23 +232,6 @@ void CycleGraph::dumpGraphToFile(const char *filename) const } #endif -/** - * Checks whether one ModelAction can reach another. - * @param from The ModelAction from which to begin exploration - * @param to The ModelAction to reach - * @return True, @a from can reach @a to; otherwise, false - */ -bool CycleGraph::checkReachable(const ModelAction *from, const ModelAction *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 @@ -179,87 +240,75 @@ bool CycleGraph::checkReachable(const ModelAction *from, const ModelAction *to) */ 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++) { + 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); } } } return false; } -bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) const +/** + * 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 { - std::vector< CycleNode *, ModelAlloc > queue; - discovered->reset(); - CycleNode *from = actionToNode.get(fromact); - - queue.push_back(from); - discovered->put(from, from); - while (!queue.empty()) { - CycleNode *node = queue.back(); - queue.pop_back(); + CycleNode *fromnode = getNode_noCreate(from); + CycleNode *tonode = getNode_noCreate(to); - if (promise->eliminate_thread(node->getAction()->get_tid())) { - return true; - } + if (!fromnode || !tonode) + return false; - 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); - } - } - } - return false; + return checkReachable(fromnode, tonode); } +/* Instantiate four forms of CycleGraph::checkReachable */ +template bool CycleGraph::checkReachable(const ModelAction *from, + const ModelAction *to) const; +/** @brief Begin a new sequence of graph additions which can be rolled back */ void CycleGraph::startChanges() { - ASSERT(rollbackvector.size() == 0); - ASSERT(rmwrollbackvector.size() == 0); + ASSERT(rollbackvector.empty()); + ASSERT(rmwrollbackvector.empty()); ASSERT(oldCycles == hasCycles); - ASSERT(oldRMWViolation == hasRMWViolation); } /** Commit changes to the cyclegraph. */ void CycleGraph::commitChanges() { - rollbackvector.resize(0); - rmwrollbackvector.resize(0); + rollbackvector.clear(); + rmwrollbackvector.clear(); oldCycles = hasCycles; - oldRMWViolation = hasRMWViolation; } /** Rollback changes to the previous commit. */ void CycleGraph::rollbackChanges() { - for (unsigned int i = 0; i < rollbackvector.size(); i++) { - rollbackvector[i]->popEdge(); - } + for (unsigned int i = 0;i < rollbackvector.size();i++) + rollbackvector[i]->removeEdge(); - for (unsigned int i = 0; i < rmwrollbackvector.size(); i++) { + for (unsigned int i = 0;i < rmwrollbackvector.size();i++) rmwrollbackvector[i]->clearRMW(); - } hasCycles = oldCycles; - hasRMWViolation = oldRMWViolation; - rollbackvector.resize(0); - rmwrollbackvector.resize(0); + rollbackvector.clear(); + rmwrollbackvector.clear(); } /** @returns whether a CycleGraph contains cycles. */ @@ -268,11 +317,6 @@ bool CycleGraph::checkForCycles() const return hasCycles; } -bool CycleGraph::checkForRMWViolation() const -{ - return hasRMWViolation; -} - /** * @brief Constructor for a CycleNode * @param act The ModelAction for this node @@ -285,7 +329,7 @@ CycleNode::CycleNode(const ModelAction *act) : /** * @param i The index of the edge to return - * @returns The a CycleNode edge indexed by i + * @returns The CycleNode edge indexed by i */ CycleNode * CycleNode::getEdge(unsigned int i) const { @@ -298,16 +342,69 @@ unsigned int CycleNode::getNumEdges() const return edges.size(); } +/** + * @param i The index of the back edge to return + * @returns The CycleNode back-edge indexed by i + */ CycleNode * CycleNode::getBackEdge(unsigned int i) const { return back_edges[i]; } +/** @returns The number of edges entering this CycleNode */ unsigned int CycleNode::getNumBackEdges() const { return back_edges.size(); } +/** + * @brief Remove an element from a vector + * @param v The vector + * @param n The element to remove + * @return True if the element was found; false otherwise + */ +template +static bool vector_remove_node(SnapVector& v, const T n) +{ + for (unsigned int i = 0;i < v.size();i++) { + if (v[i] == n) { + v.erase(v.begin() + i); + return true; + } + } + return false; +} + +/** + * @brief Remove a (forward) edge from this CycleNode + * @return The CycleNode which was popped, if one exists; otherwise NULL + */ +CycleNode * CycleNode::removeEdge() +{ + if (edges.empty()) + return NULL; + + CycleNode *ret = edges.back(); + edges.pop_back(); + vector_remove_node(ret->back_edges, this); + return ret; +} + +/** + * @brief Remove a (back) edge from this CycleNode + * @return The CycleNode which was popped, if one exists; otherwise NULL + */ +CycleNode * CycleNode::removeBackEdge() +{ + if (back_edges.empty()) + return NULL; + + CycleNode *ret = back_edges.back(); + back_edges.pop_back(); + vector_remove_node(ret->edges, this); + return ret; +} + /** * Adds an edge from this CycleNode to another CycleNode. * @param node The node to which we add a directed edge @@ -315,7 +412,7 @@ unsigned int CycleNode::getNumBackEdges() const */ bool CycleNode::addEdge(CycleNode *node) { - for (unsigned int i = 0; i < edges.size(); i++) + for (unsigned int i = 0;i < edges.size();i++) if (edges[i] == node) return false; edges.push_back(node);