edits

diff --git a/src/AST/set.cc b/src/AST/set.cc
index 6e150ff5f971a634fd128cfef195df4f7c7f7d12..c3050ec3f0c0e83ee24d87beb70466c59e8a4cf9 100644 (file)
--- a/src/AST/set.cc
+++ b/src/AST/set.cc
@@ -32,12 +32,24 @@ bool Set::exists(uint64_t element) {
        if (isRange) {
                return element >= low && element <= high;
        } else {
-               uint size = members->getSize();
-               for (uint i = 0; i < size; i++) {
-                       if (element == members->get(i))
+               //Use Binary Search
+               uint low=0;
+               uint high=members->getSize()-1;
+               while(true) {
+                       uint middle=(low+high)/2;
+                       uint64_t val=members->get(middle);
+                       if (element < val) {
+                               high=middle;
+                               if (middle==low)
+                                       return false;
+                       } else if (element > val) {
+                               low=middle;
+                               if (middle==high)
+                                       return false;
+                       } else {
                                return true;
+                       }
                }
-               return false;
        }
 }
 

diff --git a/src/AST/set.h b/src/AST/set.h
index 2eb482847227bc995ac2d648a3ea92df599aef0c..088eca577cd7b75611d9c4095dbd87625e7395b2 100644 (file)
--- a/src/AST/set.h
+++ b/src/AST/set.h
@@ -34,7 +34,6 @@ protected:
        uint64_t low;//also used to count unique items
        uint64_t high;
        Vector<uint64_t> *members;
-
 };
 
 #endif/* SET_H */

diff --git a/src/ASTAnalyses/Encoding/subgraph.cc b/src/ASTAnalyses/Encoding/subgraph.cc
index ceca9b026999f4c7789620523e40de2965453427..69fb36743a872e66eec1932604988fa79a10263d 100644 (file)
--- a/src/ASTAnalyses/Encoding/subgraph.cc
+++ b/src/ASTAnalyses/Encoding/subgraph.cc
@@ -66,6 +66,102 @@ SetIteratorEncodingNode * EncodingSubGraph::nodeIterator() {
 }
 
 void EncodingSubGraph::encode() {
+       computeEncodingValue();
+       computeInequalities();
+}
+
+void EncodingSubGraph::computeInequalities() {
+       SetIteratorEncodingNode *nodeit=nodes.iterator();
+       while(nodeit->hasNext()) {
+               EncodingNode *node=nodeit->next();
+               SetIteratorEncodingEdge *edgeit=node->edges.iterator();
+               while(edgeit->hasNext()) {
+                       EncodingEdge *edge=edgeit->next();
+                       if (edge->numComparisons == 0)
+                               continue;
+                       if (edge->left == NULL || !nodes.contains(edge->left))
+                               continue;
+                       if (edge->right == NULL || !nodes.contains(edge->right))
+                               continue;
+                       //examine only once
+                       if (edge->left != node)
+                               continue;
+                       //We have a comparison edge between two nodes in the subgraph
+                       generateComparison(edge->left, edge->right);
+               }
+               delete edgeit;
+       }
+       delete nodeit;
+}
+
+void EncodingSubGraph::generateComparison(EncodingNode *left, EncodingNode *right) {
+       Set *lset=left->s;
+       Set *rset=right->s;
+       uint lindex=0, rindex=0;
+       uint lSize=lset->getSize(), rSize=rset->getSize();
+       uint64_t lVal=lset->getElement(lindex);
+       NodeValuePair nvp1(left, lVal);
+       EncodingValue *lev = map.get(&nvp1);
+       lev->inComparison = true;
+       uint64_t rVal=rset->getElement(rindex);
+       NodeValuePair nvp2(right, rVal);
+       EncodingValue *rev = map.get(&nvp2);
+       rev->inComparison = true;
+       EncodingValue *last = NULL;
+
+       while(lindex < lSize || rindex < rSize) {
+               if (last != NULL) {
+                       if (lev != NULL)
+                               last->larger.push(lev);
+                       if (rev != NULL && lev != rev)
+                               last->larger.push(rev);
+               }
+               if (lev != rev) {
+                       if (rev == NULL || lVal < rVal) {
+                               if (rev != NULL)
+                                       lev->larger.push(rev);
+                               last = lev;
+                               if (++lindex < lSize) {
+                                       lVal=lset->getElement(lindex);
+                                       NodeValuePair nvpl(left, lVal);
+                                       lev = map.get(&nvpl);
+                                       lev->inComparison = true;
+                               } else
+                                       lev = NULL;
+                       } else {
+                               if (lev != NULL)
+                                       rev->larger.push(lev);
+                               last = rev;
+                               if (++rindex < rSize) {
+                                       rVal=rset->getElement(rindex);
+                                       NodeValuePair nvpr(right, rVal);
+                                       rev = map.get(&nvpr);
+                                       rev->inComparison = true;
+                               } else
+                                       rev = NULL;
+                       }
+               } else {
+                       last = lev;
+                       if (++lindex < lSize) {
+                               lVal=lset->getElement(lindex);
+                               NodeValuePair nvpl(left, lVal);
+                               lev = map.get(&nvpl);
+                               lev->inComparison = true;
+                       } else
+                               lev = NULL;
+
+                       if (++rindex < rSize) {
+                               rVal=rset->getElement(rindex);
+                               NodeValuePair nvpr(right, rVal);
+                               rev = map.get(&nvpr);
+                               rev->inComparison = true;
+                       } else
+                               rev = NULL;
+               }
+       }
+}
+
+void EncodingSubGraph::computeEncodingValue() {
        SetIteratorEncodingNode *nodeit=nodes.iterator();
        while(nodeit->hasNext()) {
                EncodingNode *node=nodeit->next();
@@ -83,5 +179,30 @@ void EncodingSubGraph::encode() {
 }
 
 void EncodingSubGraph::traverseValue(EncodingNode *node, uint64_t value) {
-       
+       EncodingValue *ecv=new EncodingValue(value);
+       HashsetEncodingNode discovered;
+       Vector<EncodingNode *> tovisit;
+       tovisit.push(node);
+       discovered.add(node);
+       while(tovisit.getSize()!=0) {
+               EncodingNode *n=tovisit.last();tovisit.pop();
+               //Add encoding node to structures
+               ecv->nodes.add(n);
+               NodeValuePair *nvp=new NodeValuePair(n, value);
+               map.put(nvp, ecv);
+               SetIteratorEncodingEdge *edgeit=node->edges.iterator();
+               while(edgeit->hasNext()) {
+                       EncodingEdge *ee=edgeit->next();
+                       if (!discovered.contains(ee->left) && nodes.contains(ee->left) && ee->left->s->exists(value)) {
+                               tovisit.push(ee->left);
+                               discovered.add(ee->left);
+                       }
+                       if (!discovered.contains(ee->right) && nodes.contains(ee->right) && ee->right->s->exists(value)) {
+                               tovisit.push(ee->right);
+                               discovered.add(ee->right);
+                       }
+               }
+               delete edgeit;
+       }
 }
+

diff --git a/src/ASTAnalyses/Encoding/subgraph.h b/src/ASTAnalyses/Encoding/subgraph.h
index 5520709be9360f6cfa61685d09ff89a117d00d0b..bc7fdbf5bb8164ed64261ec3398e9fa31f75f881 100644 (file)
--- a/src/ASTAnalyses/Encoding/subgraph.h
+++ b/src/ASTAnalyses/Encoding/subgraph.h
@@ -13,9 +13,12 @@ class NodeValuePair {
 
 class EncodingValue {
  public:
+ EncodingValue(uint64_t _val) : value(_val), inComparison(false) {}
        void merge(EncodingValue *value);
        uint64_t value;
+       bool inComparison;
        HashsetEncodingNode nodes;
+       Vector<EncodingValue *> larger;
 };
 
 uint hashNodeValuePair(NodeValuePair *nvp);
@@ -35,8 +38,10 @@ class EncodingSubGraph {
        uint estimateNewSize(EncodingNode *n);
        uint estimateNewSize(EncodingSubGraph *sg);
        void traverseValue(EncodingNode *node, uint64_t value);
+       void computeEncodingValue();
+       void computeInequalities();
+       void generateComparison(EncodingNode *left, EncodingNode *right);
 
-       
        HashsetEncodingNode nodes;
        NVPMap map;
        uint encodingSize;