X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=cyclegraph.cc;h=47951d4eb645b8f181b3afe6e5cc01ad49260dc4;hb=241f7577895a5c74aad14d9903b6c25ea02e217d;hp=b13837293c665e9eacc4a4440e91631770c22347;hpb=58a4edbf1f1eba39ebe6386df49ea6ff7655a206;p=c11tester.git diff --git a/cyclegraph.cc b/cyclegraph.cc index b1383729..47951d4e 100644 --- a/cyclegraph.cc +++ b/cyclegraph.cc @@ -1,21 +1,19 @@ #include "cyclegraph.h" #include "action.h" #include "common.h" -#include "promise.h" -#include "model.h" +#include "threads-model.h" +#include "clockvector.h" /** Initializes a CycleGraph object. */ CycleGraph::CycleGraph() : - discovered(new HashTable(16)), - hasCycles(false), - oldCycles(false) + queue(new SnapVector()) { } /** CycleGraph destructor */ CycleGraph::~CycleGraph() { - delete discovered; + delete queue; } /** @@ -31,39 +29,12 @@ 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); -} - -/** - * @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); -} - /** @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 * @@ -82,172 +53,71 @@ CycleNode * CycleGraph::getNode(const ModelAction *action) return node; } -/** - * @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 - */ -CycleNode * CycleGraph::getNode(const Promise *promise) -{ - CycleNode *node = getNode_noCreate(promise); - if (node == NULL) { - node = new CycleNode(promise); - putNode(promise, node); - } - return node; -} - -/** - * @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); - erasePromiseNode(promise_node->getPromise()); - 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 the RMW */ - CycleNode *promise_rmw = p_node->getRMW(); - if (promise_rmw && promise_rmw != w_node->getRMW() && w_node->setRMW(promise_rmw)) - hasCycles = true; - - /* Transfer back edges to w_node */ - while (p_node->getNumBackEdges() > 0) { - CycleNode *back = p_node->removeBackEdge(); - 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 - 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) - continue; - 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); - } - - erasePromiseNode(promise); - 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) +void CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode, bool forceedge) { - bool added; - - if (!hasCycles) - hasCycles = checkReachable(tonode, fromnode); - - if ((added = fromnode->addEdge(tonode))) - rollbackvector.push_back(fromnode); + //quick check whether edge is redundant + if (checkReachable(fromnode, tonode) && !forceedge) { + return; + } /* - * 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, we should + * follow its RMW chain to add an edge at the end. */ - CycleNode *rmwnode = fromnode->getRMW(); - if (rmwnode && rmwnode != tonode) { - if (!hasCycles) - hasCycles = checkReachable(tonode, rmwnode); - - if (rmwnode->addEdge(tonode)) { - rollbackvector.push_back(rmwnode); - added = true; + while (fromnode->getRMW()) { + CycleNode *nextnode = fromnode->getRMW(); + if (nextnode == tonode) + break; + fromnode = nextnode; + } + + fromnode->addEdge(tonode); //Add edge to edgeSrcNode + + /* Propagate clock vector changes */ + if (tonode->cv->merge(fromnode->cv)) { + queue->push_back(fromnode); + while(!queue->empty()) { + const CycleNode *node = queue->back(); + queue->pop_back(); + unsigned int numedges = node->getNumEdges(); + for(unsigned int i = 0;i < numedges;i++) { + CycleNode * enode = node->getEdge(i); + if (enode->cv->merge(node->cv)) + queue->push_back(enode); + } } } - 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/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. + * the ModelAction 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 from The edge comes from this ModelAction * @param rmw The edge points to this ModelAction; this action must read from - * the ModelAction/Promise from + * the ModelAction from */ -template -void CycleGraph::addRMWEdge(const T *from, const ModelAction *rmw) +void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) { ASSERT(from); ASSERT(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)) - hasCycles = true; - else - rmwrollbackvector.push_back(fromnode); + fromnode->setRMW(rmwnode); /* Transfer all outgoing edges from the from node to the rmw node */ /* This process should not add a cycle because either: @@ -256,19 +126,16 @@ void CycleGraph::addRMWEdge(const T *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)) - rollbackvector.push_back(rmwnode); + rmwnode->addEdge(tonode); } } + fromnode->edges.clear(); - addNodeEdge(fromnode, rmwnode); + addNodeEdge(fromnode, rmwnode, true); } -/* 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 @@ -283,8 +150,8 @@ template void CycleGraph::addRMWEdge(const Promise *from, const ModelAction *rmw * @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) + +void CycleGraph::addEdge(const ModelAction *from, const ModelAction *to) { ASSERT(from); ASSERT(to); @@ -292,28 +159,64 @@ bool CycleGraph::addEdge(const T *from, const U *to) CycleNode *fromnode = getNode(from); CycleNode *tonode = getNode(to); - return addNodeEdge(fromnode, tonode); + addNodeEdge(fromnode, tonode, false); +} + +void CycleGraph::addEdge(const ModelAction *from, const ModelAction *to, bool forceedge) +{ + ASSERT(from); + ASSERT(to); + + CycleNode *fromnode = getNode(from); + CycleNode *tonode = getNode(to); + + addNodeEdge(fromnode, tonode, forceedge); } -/* Instantiate three 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); #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); +} + +void CycleGraph::dot_print_edge(FILE *file, const ModelAction *from, const ModelAction *to, const char *prop) +{ + CycleNode *fromnode = getNode(from); + CycleNode *tonode = getNode(to); + + print_edge(file, fromnode, tonode, 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); } } @@ -337,36 +240,16 @@ void CycleGraph::dumpGraphToFile(const char *filename) const */ 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()) { - const CycleNode *node = queue.back(); - queue.pop_back(); - if (node == to) - return true; - - 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 to->cv->synchronized_since(from->action); } /** - * Checks whether one ModelAction can reach another ModelAction/Promise + * Checks whether one ModelAction can reach another ModelAction * @param from The ModelAction from which to begin exploration - * @param to The ModelAction or Promise to reach + * @param to The ModelAction to reach * @return True, @a from can reach @a to; otherwise, false */ -template -bool CycleGraph::checkReachable(const ModelAction *from, const T *to) const +bool CycleGraph::checkReachable(const ModelAction *from, const ModelAction *to) const { CycleNode *fromnode = getNode_noCreate(from); CycleNode *tonode = getNode_noCreate(to); @@ -376,74 +259,6 @@ bool CycleGraph::checkReachable(const ModelAction *from, const T *to) const return checkReachable(fromnode, tonode); } -/* Instantiate two 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; - -/** @return True, if the promise has failed; false otherwise */ -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(); - queue.pop_back(); - - 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); - if (!discovered->contains(next)) { - discovered->put(next, next); - queue.push_back(next); - } - } - } - return false; -} - -void CycleGraph::startChanges() -{ - ASSERT(rollbackvector.empty()); - ASSERT(rmwrollbackvector.empty()); - ASSERT(oldCycles == hasCycles); -} - -/** Commit changes to the cyclegraph. */ -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++) - rollbackvector[i]->removeEdge(); - - for (unsigned int i = 0; i < rmwrollbackvector.size(); i++) - rmwrollbackvector[i]->clearRMW(); - - hasCycles = oldCycles; - rollbackvector.clear(); - rmwrollbackvector.clear(); -} - -/** @returns whether a CycleGraph contains cycles. */ -bool CycleGraph::checkForCycles() const -{ - return hasCycles; -} /** * @brief Constructor for a CycleNode @@ -451,25 +266,14 @@ bool CycleGraph::checkForCycles() const */ 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) + hasRMW(NULL), + cv(new ClockVector(NULL, 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 { @@ -482,34 +286,6 @@ 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 @@ -521,22 +297,6 @@ CycleNode * CycleNode::removeEdge() 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; } @@ -545,14 +305,12 @@ CycleNode * CycleNode::removeBackEdge() * @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) +void 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; + return; edges.push_back(node); - node->back_edges.push_back(this); - return true; } /** @returns the RMW CycleNode that reads from the current CycleNode */ @@ -574,19 +332,3 @@ 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()); -}