Fix bug regarding order translation for removed nodes

diff --git a/src/ASTAnalyses/Encoding/encodinggraph.cc b/src/ASTAnalyses/Encoding/encodinggraph.cc
index 9f9bb047a1908bda9858b14a96087225ab9f5072..f0cd8300b44bad06889287b3625c23784a6c8b3e 100644 (file)
--- a/src/ASTAnalyses/Encoding/encodinggraph.cc
+++ b/src/ASTAnalyses/Encoding/encodinggraph.cc
@@ -81,13 +81,10 @@ void EncodingGraph::encode() {
                                                continue;
                                        uint encodingSize = subgraph->getEncodingMaxVal(n)+1;
                                        uint paddedSize = encoding->getSizeEncodingArray(encodingSize);
-                                       model_print("encoding size=%u\n", encodingSize);
-                                       model_print("padded=%u\n", paddedSize);
                                        encoding->allocInUseArrayElement(paddedSize);
                                        encoding->allocEncodingArrayElement(paddedSize);
                                        Set *s = e->getRange();
                                        for (uint i = 0; i < s->getSize(); i++) {
-                                               model_print("index=%u\n", i);
                                                uint64_t value = s->getElement(i);
                                                uint encodingIndex = subgraph->getEncoding(n, value);
                                                encoding->setInUseElement(encodingIndex);

diff --git a/src/ASTAnalyses/Order/ordernode.cc b/src/ASTAnalyses/Order/ordernode.cc
index 02f314694d31039468b7e31e60f3f10d33cb3c88..41b11a57240ea3b4a2b79188f61218f317defd4c 100644 (file)
--- a/src/ASTAnalyses/Order/ordernode.cc
+++ b/src/ASTAnalyses/Order/ordernode.cc
@@ -4,6 +4,7 @@
 OrderNode::OrderNode(uint64_t _id) :
        id(_id),
        status(NOTVISITED),
+       removed(false),
        sccNum(0),
        inEdges(),
        outEdges() {

diff --git a/src/ASTAnalyses/Order/ordernode.h b/src/ASTAnalyses/Order/ordernode.h
index 0ae88679b956252f13b14da8c4338681bfd61fee..a9bc1d3f4cb596052ab6fc0191440db373d0e53c 100644 (file)
--- a/src/ASTAnalyses/Order/ordernode.h
+++ b/src/ASTAnalyses/Order/ordernode.h
@@ -26,6 +26,7 @@ public:
 
        uint64_t id;
        NodeStatus status;
+       bool removed;
        uint sccNum;
        HashsetOrderEdge inEdges;
        HashsetOrderEdge outEdges;

diff --git a/src/ASTTransform/decomposeordertransform.cc b/src/ASTTransform/decomposeordertransform.cc
index fd5fda8fed7fcb6fd46b18a7648b1fa564f9637f..51d6a51b1f0d14401638c45b963b8f48827982f4 100644 (file)
--- a/src/ASTTransform/decomposeordertransform.cc
+++ b/src/ASTTransform/decomposeordertransform.cc
@@ -191,6 +191,7 @@ bool DecomposeOrderTransform::isMustBeTrueNode(OrderNode *node) {
 }
 
 void DecomposeOrderTransform::bypassMustBeTrueNode(OrderGraph *graph, OrderNode *node, HashsetOrderEdge *edgesRemoved) {
+       node->removed = true;
        SetIteratorOrderEdge *iterin = node->inEdges.iterator();
        while (iterin->hasNext()) {
                OrderEdge *inEdge = iterin->next();

diff --git a/src/Translator/decomposeorderresolver.cc b/src/Translator/decomposeorderresolver.cc
index 64ebc3426e925ce2310037d017654e2e9f12f3f1..1e5fdf0cca7dc43cee7fc532e938aaed665e5bae 100644 (file)
--- a/src/Translator/decomposeorderresolver.cc
+++ b/src/Translator/decomposeorderresolver.cc
@@ -20,27 +20,65 @@ DecomposeOrderResolver::DecomposeOrderResolver(OrderGraph *_graph, Vector<Order
 DecomposeOrderResolver::~DecomposeOrderResolver() {
 }
 
+void processNode(HashsetOrderNode * set, OrderNode *node, bool outedges) {
+       if (node->removed) {
+               Vector<OrderNode *> toprocess;
+               HashsetOrderNode visited;
+               toprocess.push(node);
+               while(toprocess.getSize()!=0) {
+                       OrderNode *newnode=toprocess.last();toprocess.pop();
+                       SetIteratorOrderEdge *iterator=outedges ? newnode->outEdges.iterator() : newnode->inEdges.iterator();
+                       while(iterator->hasNext()) {
+                               OrderEdge *edge=iterator->next();
+                               OrderNode *tmpnode=outedges ? edge->sink : edge->source;
+                               if (tmpnode->removed) {
+                                       if (visited.add(tmpnode)) {
+                                               toprocess.push(tmpnode);
+                                       }
+                               } else {
+                                       set->add(tmpnode);
+                               }
+                       }
+                       delete iterator;
+               }
+       } else
+               set->add(node);
+}
+
 bool DecomposeOrderResolver::resolveOrder(uint64_t first, uint64_t second) {
        OrderNode *from = graph->lookupOrderNodeFromOrderGraph(first);
        ASSERT(from != NULL);
        OrderNode *to = graph->lookupOrderNodeFromOrderGraph(second);
        ASSERT(to != NULL);
-
-       if (from->sccNum != to->sccNum) {
-               OrderEdge *edge = graph->lookupOrderEdgeFromOrderGraph(from, to);
-               if (edge != NULL && edge->mustPos) {
-                       return true;
-               } else if ( edge != NULL && edge->mustNeg) {
-                       return false;
-               } else {
-                       switch (graph->getOrder()->type) {
-                       case SATC_TOTAL:
-                               return from->sccNum < to->sccNum;
-                       case SATC_PARTIAL:
-                               return resolvePartialOrder(from, to);
-                       default:
-                               ASSERT(0);
+       if (from->removed || to->removed) {
+               HashsetOrderNode fromset, toset;
+               processNode(&fromset, from, true);
+               processNode(&toset, to, false);
+               SetIteratorOrderNode *fromit=fromset.iterator();
+               while(fromit->hasNext()) {
+                       OrderNode * nodefrom=fromit->next();
+                       SetIteratorOrderNode *toit=toset.iterator();
+                       while(toit->hasNext()) {
+                               OrderNode * nodeto=toit->next();
+                               if (resolveOrder(nodefrom->getID(), nodeto->getID())) {
+                                       delete fromit;
+                                       delete toit;
+                                       return true;
+                               }
                        }
+                       delete toit;
+               }
+               delete fromit;
+               return false;
+       } else if (from->sccNum != to->sccNum) {
+               OrderEdge *edge = graph->lookupOrderEdgeFromOrderGraph(from, to);
+               switch (graph->getOrder()->type) {
+               case SATC_TOTAL:
+                       return from->sccNum < to->sccNum;
+               case SATC_PARTIAL:
+                       return resolvePartialOrder(from, to);
+               default:
+                       ASSERT(0);
                }
        } else {
                Order *suborder = NULL;