X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=cyclegraph.cc;h=49c462f5375c0695bb07d10b18f82ee156a73b29;hb=07aa7bafa42e3909d74889e5ed70fff3ab05d0f0;hp=2280e76e3e208b8ac6ce6e2044433c1a866d2c85;hpb=c832cb55af09e735821ae3463bc37c29d3fa27c8;p=model-checker.git diff --git a/cyclegraph.cc b/cyclegraph.cc index 2280e76..49c462f 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -6,15 +6,29 @@ /** Initializes a CycleGraph object. */ CycleGraph::CycleGraph() : + discovered(new HashTable(16)), hasCycles(false), - oldCycles(false), - hasRMWViolation(false), - oldRMWViolation(false) + oldCycles(false) { } /** CycleGraph destructor */ -CycleGraph::~CycleGraph() { +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 } /** @@ -22,80 +36,92 @@ CycleGraph::~CycleGraph() { * @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); - if (node==NULL) { - node=new CycleNode(action); - actionToNode.put(action, node); -#if SUPPORT_MOD_ORDER_DUMP - nodeList.push_back(node); -#endif +CycleNode * CycleGraph::getNode(const ModelAction *action) +{ + CycleNode *node = actionToNode.get(action); + if (node == NULL) { + node = new CycleNode(action); + putNode(action, node); } return node; } /** - * 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 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 */ -void CycleGraph::addEdge(const ModelAction *from, const ModelAction *to) { +template +void CycleGraph::addEdge(const T from, const U to) +{ ASSERT(from); ASSERT(to); - ASSERT(from != to); - CycleNode *fromnode=getNode(from); - CycleNode *tonode=getNode(to); + CycleNode *fromnode = getNode(from); + CycleNode *tonode = getNode(to); - if (!hasCycles) { - // Check for Cycles - hasCycles=checkReachable(tonode, fromnode); - } + addNodeEdge(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::addNodeEdge(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 - hasCycles=checkReachable(tonode, rmwnode); - } + /* + * If the fromnode has a rmwnode that is not the tonode, we should add + * an edge between its rmwnode and the tonode + */ + 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) { +void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) +{ ASSERT(from); ASSERT(rmw); - ASSERT(from != rmw); - CycleNode *fromnode=getNode(from); - CycleNode *rmwnode=getNode(rmw); + CycleNode *fromnode = getNode(from); + 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: @@ -104,51 +130,44 @@ 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. */ - std::vector * edges=fromnode->getEdges(); - for(unsigned int i=0;isize();i++) { - CycleNode * tonode=(*edges)[i]; - if (tonode!=rmwnode) { + for (unsigned int i = 0; i < fromnode->getNumEdges(); i++) { + CycleNode *tonode = fromnode->getEdge(i); + if (tonode != rmwnode) { if (rmwnode->addEdge(tonode)) rollbackvector.push_back(rmwnode); } } - - 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); + addNodeEdge(fromnode, rmwnode); } #if SUPPORT_MOD_ORDER_DUMP -void CycleGraph::dumpNodes(FILE *file) { - for(unsigned int i=0;i * edges=cn->getEdges(); - 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) { +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;jsize();j++) { - CycleNode *dst=(*edges)[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 < 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()); + } } } -void CycleGraph::dumpGraphToFile(const char *filename) { +void CycleGraph::dumpGraphToFile(const char *filename) const +{ char buffer[200]; - sprintf(buffer, "%s.dot",filename); - FILE *file=fopen(buffer, "w"); - fprintf(file, "digraph %s {\n",filename); + sprintf(buffer, "%s.dot", filename); + FILE *file = fopen(buffer, "w"); + fprintf(file, "digraph %s {\n", filename); dumpNodes(file); - fprintf(file,"}\n"); - fclose(file); + fprintf(file, "}\n"); + fclose(file); } #endif @@ -158,7 +177,8 @@ void CycleGraph::dumpGraphToFile(const char *filename) { * @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) { +bool CycleGraph::checkReachable(const ModelAction *from, const ModelAction *to) const +{ CycleNode *fromnode = actionToNode.get(from); CycleNode *tonode = actionToNode.get(to); @@ -174,22 +194,23 @@ 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) { - std::vector > queue; - HashTable discovered(64); +bool CycleGraph::checkReachable(const CycleNode *from, const CycleNode *to) const +{ + std::vector< const CycleNode *, ModelAlloc > queue; + discovered->reset(); queue.push_back(from); - discovered.put(from, from); - while(!queue.empty()) { - CycleNode * node=queue.back(); + discovered->put(from, from); + while (!queue.empty()) { + const CycleNode *node = queue.back(); queue.pop_back(); - if (node==to) + if (node == to) return true; - for(unsigned int i=0;igetEdges()->size();i++) { - CycleNode *next=(*node->getEdges())[i]; - if (!discovered.contains(next)) { - discovered.put(next,next); + 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); } } @@ -197,26 +218,26 @@ bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to) { return false; } -bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) { - std::vector > queue; - HashTable discovered(64); +bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) 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(); + discovered->put(from, from); + while (!queue.empty()) { + 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; } - for(unsigned int i=0;igetEdges()->size();i++) { - CycleNode *next=(*node->getEdges())[i]; - if (!discovered.contains(next)) { - discovered.put(next,next); + 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); } } @@ -224,75 +245,154 @@ bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) { return false; } -void CycleGraph::startChanges() { - ASSERT(rollbackvector.size()==0); - ASSERT(rmwrollbackvector.size()==0); - ASSERT(oldCycles==hasCycles); - ASSERT(oldRMWViolation==hasRMWViolation); +void CycleGraph::startChanges() +{ + ASSERT(rollbackvector.empty()); + ASSERT(rmwrollbackvector.empty()); + ASSERT(oldCycles == hasCycles); } /** Commit changes to the cyclegraph. */ -void CycleGraph::commitChanges() { - rollbackvector.resize(0); - rmwrollbackvector.resize(0); - oldCycles=hasCycles; - oldRMWViolation=hasRMWViolation; +void CycleGraph::commitChanges() +{ + rollbackvector.clear(); + rmwrollbackvector.clear(); + oldCycles = hasCycles; } /** Rollback changes to the previous commit. */ -void CycleGraph::rollbackChanges() { - for (unsigned int i = 0; i < rollbackvector.size(); i++) { +void CycleGraph::rollbackChanges() +{ + 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. */ -bool CycleGraph::checkForCycles() { +bool CycleGraph::checkForCycles() const +{ return hasCycles; } -bool CycleGraph::checkForRMWViolation() { - 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) +{ } /** - * Constructor for a CycleNode. - * @param modelaction The ModelAction for this node + * @brief Constructor for a Promise CycleNode + * @param promise The Promise which was generated */ -CycleNode::CycleNode(const ModelAction *modelaction) : - action(modelaction), +CycleNode::CycleNode(const Promise *promise) : + action(NULL), + promise(promise), hasRMW(NULL) { } -/** @returns a vector of the edges from a CycleNode. */ -std::vector * CycleNode::getEdges() { - return &edges; +/** + * @param i The index of the edge to return + * @returns The a CycleNode edge indexed by i + */ +CycleNode * CycleNode::getEdge(unsigned int i) const +{ + return edges[i]; +} + +/** @returns The number of edges leaving this CycleNode */ +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) { - for(unsigned int i=0;iback_edges.push_back(this); return true; } /** @returns the RMW CycleNode that reads from the current CycleNode */ -CycleNode * CycleNode::getRMW() { +CycleNode * CycleNode::getRMW() const +{ return hasRMW; } @@ -302,9 +402,10 @@ CycleNode * CycleNode::getRMW() { * @return True, if this node already was read by another RMW; false otherwise * @see CycleGraph::addRMWEdge */ -bool CycleNode::setRMW(CycleNode *node) { - if (hasRMW!=NULL) +bool CycleNode::setRMW(CycleNode *node) +{ + if (hasRMW != NULL) return true; - hasRMW=node; + hasRMW = node; return false; }