X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=cyclegraph.cc;h=57f8fc8c42fe0033abbe83d14caa674feeedb1e7;hb=eb07120dfdbb206124f7857016a71b6ef0b9eb99;hp=168ad90cdb0c4930d045d2dd97d2d45cc2e2f068;hpb=86c1040ac133d94bcafac7e72b7a8353d2b5757d;p=model-checker.git diff --git a/cyclegraph.cc b/cyclegraph.cc index 168ad90..57f8fc8 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -6,11 +6,9 @@ /** Initializes a CycleGraph object. */ CycleGraph::CycleGraph() : - discovered(new HashTable(16)), + discovered(new HashTable(16)), hasCycles(false), - oldCycles(false), - hasRMWViolation(false), - oldRMWViolation(false) + oldCycles(false) { } @@ -20,6 +18,19 @@ CycleGraph::~CycleGraph() delete discovered; } +/** + * Add a CycleNode to the graph, corresponding to a store ModelAction + * @param act The write action that should be added + * @param node The CycleNode that corresponds to the store + */ +void CycleGraph::putNode(const ModelAction *act, CycleNode *node) +{ + actionToNode.put(act, node); +#if SUPPORT_MOD_ORDER_DUMP + nodeList.push_back(node); +#endif +} + /** * @brief Returns the CycleNode corresponding to a given ModelAction * @param action The ModelAction to find a node for @@ -30,10 +41,7 @@ CycleNode * CycleGraph::getNode(const ModelAction *action) CycleNode *node = actionToNode.get(action); if (node == NULL) { node = new CycleNode(action); - actionToNode.put(action, node); -#if SUPPORT_MOD_ORDER_DUMP - nodeList.push_back(node); -#endif + putNode(action, node); } return node; } @@ -52,44 +60,47 @@ void CycleGraph::addEdge(const ModelAction *from, const ModelAction *to) CycleNode *fromnode = getNode(from); CycleNode *tonode = getNode(to); - if (!hasCycles) { - // Reflexive edges are cycles - hasCycles = (from == to); - } - if (!hasCycles) { - // Check for Cycles + addEdge(fromnode, tonode); +} + +/** + * Adds an edge between two CycleNodes. + * @param fromnode The edge comes from this CycleNode + * @param tonode The edge points to this CycleNode + */ +void CycleGraph::addEdge(CycleNode *fromnode, CycleNode *tonode) +{ + if (!hasCycles) hasCycles = checkReachable(tonode, fromnode); - } if (fromnode->addEdge(tonode)) rollbackvector.push_back(fromnode); - - CycleNode *rmwnode = fromnode->getRMW(); - /* * If the fromnode has a rmwnode that is not the tonode, we should add * an edge between its rmwnode and the tonode - * - * If tonode is also a rmw, don't do this check as the execution is - * doomed and we'll catch the problem elsewhere, but we want to allow - * for the possibility of sending to's write value to rmwnode */ - if (rmwnode != NULL && !to->is_rmw()) { - if (!hasCycles) { - // Check for Cycles + CycleNode *rmwnode = fromnode->getRMW(); + if (rmwnode && rmwnode != tonode) { + if (!hasCycles) hasCycles = checkReachable(tonode, rmwnode); - } if (rmwnode->addEdge(tonode)) rollbackvector.push_back(rmwnode); } } -/** 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 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 rmw The edge points to this ModelAction; this action must read from + * ModelAction from */ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) { @@ -100,11 +111,10 @@ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) CycleNode *rmwnode = getNode(rmw); /* 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: @@ -121,18 +131,7 @@ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) } } - - if (!hasCycles) { - // Reflexive edges are cycles - hasCycles = (from == rmw); - } - if (!hasCycles) { - // With promises we could be setting up a cycle here if we aren't - // careful...avoid it.. - hasCycles = checkReachable(rmwnode, fromnode); - } - if (fromnode->addEdge(rmwnode)) - rollbackvector.push_back(fromnode); + addEdge(fromnode, rmwnode); } #if SUPPORT_MOD_ORDER_DUMP @@ -188,15 +187,15 @@ bool CycleGraph::checkReachable(const ModelAction *from, const ModelAction *to) * @param to The CycleNode to reach * @return True, @a from can reach @a to; otherwise, false */ -bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to) const +bool CycleGraph::checkReachable(const CycleNode *from, const CycleNode *to) const { - std::vector< CycleNode *, ModelAlloc > queue; + std::vector< const CycleNode *, ModelAlloc > queue; discovered->reset(); queue.push_back(from); discovered->put(from, from); while (!queue.empty()) { - CycleNode *node = queue.back(); + const CycleNode *node = queue.back(); queue.pop_back(); if (node == to) return true; @@ -224,7 +223,7 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) cons CycleNode *node = queue.back(); queue.pop_back(); - if (promise->increment_threads(node->getAction()->get_tid())) { + if (promise->eliminate_thread(node->getAction()->get_tid())) { return true; } @@ -241,36 +240,31 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) cons 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++) { + for (unsigned int i = 0; i < rollbackvector.size(); i++) rollbackvector[i]->popEdge(); - } - 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. */ @@ -279,17 +273,24 @@ bool CycleGraph::checkForCycles() const return hasCycles; } -bool CycleGraph::checkForRMWViolation() const -{ - return hasRMWViolation; -} - /** * @brief Constructor for a CycleNode * @param act The ModelAction for this node */ CycleNode::CycleNode(const ModelAction *act) : action(act), + promise(NULL), + hasRMW(NULL) +{ +} + +/** + * @brief Constructor for a Promise CycleNode + * @param promise The Promise which was generated + */ +CycleNode::CycleNode(const Promise *promise) : + action(NULL), + promise(promise), hasRMW(NULL) { } @@ -309,9 +310,68 @@ unsigned int CycleNode::getNumEdges() const return edges.size(); } +CycleNode * CycleNode::getBackEdge(unsigned int i) const +{ + return back_edges[i]; +} + +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(std::vector >& 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 + * @return True if this edge is a new edge; false otherwise */ bool CycleNode::addEdge(CycleNode *node) { @@ -319,6 +379,7 @@ bool CycleNode::addEdge(CycleNode *node) if (edges[i] == node) return false; edges.push_back(node); + node->back_edges.push_back(this); return true; }