#include "cyclegraph.h"
#include "action.h"
#include "common.h"
+#include "promise.h"
+#include "model.h"
/** Initializes a CycleGraph object. */
CycleGraph::CycleGraph() :
+ discovered(new HashTable<CycleNode *, CycleNode *, uintptr_t, 4, model_malloc, model_calloc, model_free>(16)),
hasCycles(false),
oldCycles(false),
hasRMWViolation(false),
void CycleGraph::addEdge(const ModelAction *from, const ModelAction *to) {
ASSERT(from);
ASSERT(to);
- ASSERT(from != to);
CycleNode *fromnode=getNode(from);
CycleNode *tonode=getNode(to);
+ if (!hasCycles) {
+ // Reflexive edges are cycles
+ hasCycles = (from == to);
+ }
if (!hasCycles) {
// Check for Cycles
hasCycles=checkReachable(tonode, fromnode);
void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw) {
ASSERT(from);
ASSERT(rmw);
- ASSERT(from != rmw);
CycleNode *fromnode=getNode(from);
CycleNode *rmwnode=getNode(rmw);
* (2) the fromnode is the new node and therefore it should not
* have any outgoing edges.
*/
- std::vector<CycleNode *> * edges=fromnode->getEdges();
- for(unsigned int i=0;i<edges->size();i++) {
- CycleNode * tonode=(*edges)[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);
}
+ 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))
+ if (fromnode->addEdge(rmwnode))
rollbackvector.push_back(fromnode);
}
#if SUPPORT_MOD_ORDER_DUMP
-void CycleGraph::dumpGraphToFile(const char *filename) {
- char buffer[200];
- sprintf(buffer, "%s.dot",filename);
- FILE *file=fopen(buffer, "w");
- fprintf(file, "digraph %s {\n",filename);
- for(unsigned int i=0;i<nodeList.size();i++) {
+void CycleGraph::dumpNodes(FILE *file) {
+ for (unsigned int i=0;i<nodeList.size();i++) {
CycleNode *cn=nodeList[i];
- std::vector<CycleNode *> * 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) {
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<edges->size();j++) {
- CycleNode *dst=(*edges)[j];
+ 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());
- }
+ fprintf(file, "N%u -> N%u;\n", action->get_seq_number(), dstaction->get_seq_number());
+ }
}
- fprintf(file,"}\n");
- fclose(file);
+}
+
+void CycleGraph::dumpGraphToFile(const char *filename) {
+ char buffer[200];
+ sprintf(buffer, "%s.dot",filename);
+ FILE *file=fopen(buffer, "w");
+ fprintf(file, "digraph %s {\n",filename);
+ dumpNodes(file);
+ fprintf(file,"}\n");
+ fclose(file);
}
#endif
* @return True, @a from can reach @a to; otherwise, false
*/
bool CycleGraph::checkReachable(CycleNode *from, CycleNode *to) {
- std::vector<CycleNode *, MyAlloc<CycleNode *> > queue;
- HashTable<CycleNode *, CycleNode *, uintptr_t, 4, MYMALLOC, MYCALLOC, MYFREE> discovered;
+ std::vector<CycleNode *, ModelAlloc<CycleNode *> > queue;
+ discovered->reset();
queue.push_back(from);
- discovered.put(from, from);
+ discovered->put(from, from);
while(!queue.empty()) {
CycleNode * node=queue.back();
queue.pop_back();
if (node==to)
return true;
- for(unsigned int i=0;i<node->getEdges()->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);
+ }
+ }
+ }
+ return false;
+}
+
+bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) {
+ std::vector<CycleNode *, ModelAlloc<CycleNode *> > 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 (promise->increment_threads(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);
}
}
{
}
-/** @returns a vector of the edges from a CycleNode. */
-std::vector<CycleNode *> * 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();
}
/**