X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=cyclegraph.cc;h=eaddc8e1714629f8834a5b11c891f8009b2e1237;hp=9a511952b0826470befc1a2bcc7ecde85619265c;hb=62dbff8dbca80ded5959e88ec9c177bef9108546;hpb=8cebf02d9a4c9f0fe80af04f6276f4978f3b93f5 diff --git a/cyclegraph.cc b/cyclegraph.cc index 9a511952..eaddc8e1 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -8,9 +8,7 @@ CycleGraph::CycleGraph() : discovered(new HashTable(16)), hasCycles(false), - oldCycles(false), - hasRMWViolation(false), - oldRMWViolation(false) + oldCycles(false) { } @@ -33,14 +31,29 @@ 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); +} + +/** @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); @@ -49,49 +62,152 @@ 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 + * @brief Returns a CycleNode corresponding to a promise + * + * Gets (or creates, if none exist) a CycleNode corresponding to a promised + * value. + * + * @param promise The Promise generated by a reader + * @return The CycleNode corresponding to the Promise */ -void CycleGraph::addEdge(const ModelAction *from, const ModelAction *to) +CycleNode * CycleGraph::getNode(const Promise *promise) { - ASSERT(from); - ASSERT(to); + const ModelAction *reader = promise->get_action(); + CycleNode *node = getNode_noCreate(promise); + if (node == NULL) { + node = new CycleNode(promise); + readerToPromiseNode.put(reader, node); + } + return node; +} - CycleNode *fromnode = getNode(from); - CycleNode *tonode = getNode(to); +/** + * @return false if the resolution results in a cycle; true otherwise + */ +bool CycleGraph::resolvePromise(ModelAction *reader, ModelAction *writer, + promise_list_t *mustResolve) +{ + CycleNode *promise_node = readerToPromiseNode.get(reader); + CycleNode *w_node = actionToNode.get(writer); + ASSERT(promise_node); + + if (w_node) + 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 */ + putNode(writer, promise_node); + return true; +} + +/** + * @brief Merge two CycleNodes that represent the same write + * + * Note that this operation cannot be rolled back. + * + * @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 + */ +bool CycleGraph::mergeNodes(CycleNode *w_node, CycleNode *p_node, + promise_list_t *mustMerge) +{ + 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 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); + } + } + + /* 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); + } + } + + /* erase p_node */ + readerToPromiseNode.put(promise->get_action(), NULL); + delete p_node; + + return !hasCycles; +} + +/** + * 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 + */ +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); - - 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()) { + CycleNode *rmwnode = fromnode->getRMW(); + if (rmwnode && rmwnode != tonode) { if (!hasCycles) hasCycles = checkReachable(tonode, rmwnode); - if (rmwnode->addEdge(tonode)) + if (rmwnode->addEdge(tonode)) { rollbackvector.push_back(rmwnode); + added = true; + } } + return added; } -/** 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) { @@ -102,11 +218,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: @@ -123,11 +238,7 @@ void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) } } - if (!hasCycles) - hasCycles = checkReachable(rmwnode, fromnode); - - if (fromnode->addEdge(rmwnode)) - rollbackvector.push_back(fromnode); + addNodeEdge(fromnode, rmwnode); } #if SUPPORT_MOD_ORDER_DUMP @@ -160,23 +271,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 @@ -207,6 +301,7 @@ bool CycleGraph::checkReachable(const CycleNode *from, const CycleNode *to) cons return false; } +/** @return True, if the promise has failed; false otherwise */ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) const { std::vector< CycleNode *, ModelAlloc > queue; @@ -219,9 +314,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); @@ -236,36 +331,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. */ @@ -274,17 +364,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) { } @@ -314,6 +411,54 @@ 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 @@ -348,3 +493,19 @@ bool CycleNode::setRMW(CycleNode *node) hasRMW = node; return false; } + +/** + * Convert a Promise CycleNode into a concrete-valued CycleNode. Should only be + * used when there's no existing ModelAction CycleNode for this write. + * + * @param writer The ModelAction which wrote the future value represented by + * this CycleNode + */ +void CycleNode::resolvePromise(const ModelAction *writer) +{ + ASSERT(is_promise()); + ASSERT(promise->is_compatible(writer)); + action = writer; + promise = NULL; + ASSERT(!is_promise()); +}