Subgraphing code in place

diff --git a/src/AST/set.cc b/src/AST/set.cc
index 54c66798f9889d3dda6fb433f5c9b56d3547947e..6e150ff5f971a634fd128cfef195df4f7c7f7d12 100644 (file)
--- a/src/AST/set.cc
+++ b/src/AST/set.cc
@@ -82,6 +82,31 @@ Set *Set::clone(CSolver *solver, CloneMap *map) {
        return s;
 }
 
+uint Set::getUnionSize(Set *s) {
+       uint sSize = s->getSize();
+       uint thisSize = getSize();
+       uint sIndex = 0;
+       uint thisIndex = 0;
+       uint sum = 0;
+       uint64_t sValue = s->getElement(sIndex);
+       uint64_t thisValue = getElement(thisIndex);
+       while(thisIndex < thisSize && sIndex < sSize) {
+               if (sValue < thisValue) {
+                       sValue = s->getElement(++sIndex);
+                       sum++;
+               } else if (thisValue < sValue) {
+                       thisValue = getElement(++thisIndex);
+                       sum++;
+               } else {
+                       thisValue = getElement(++thisIndex);
+                       sValue = s->getElement(++sIndex);
+                       sum++;
+               }
+       }
+       sum += (thisSize - thisIndex) + (sSize - sIndex);
+       
+       return sum;
+}
 
 void Set::serialize(Serializer* serializer){
        if(serializer->isSerialized(this))

diff --git a/src/AST/set.h b/src/AST/set.h
index 6dbeac063f999b3e611cc3816f36b15eb87d5050..2eb482847227bc995ac2d648a3ea92df599aef0c 100644 (file)
--- a/src/AST/set.h
+++ b/src/AST/set.h
@@ -24,6 +24,7 @@ public:
        uint64_t getNewUniqueItem() {return low++;}
        uint64_t getMemberAt(uint index);
        uint64_t getElement(uint index);
+       uint getUnionSize(Set *s);
        virtual Set *clone(CSolver *solver, CloneMap *map);
        virtual void serialize(Serializer* serializer);
        CMEMALLOC;

diff --git a/src/ASTAnalyses/Encoding/encodinggraph.cc b/src/ASTAnalyses/Encoding/encodinggraph.cc
index 8fe908a50a475938b60dad9b000e734e04fb6d49..4fdc1c657951f587aa31206c3242a0fcdea6d1fc 100644 (file)
--- a/src/ASTAnalyses/Encoding/encodinggraph.cc
+++ b/src/ASTAnalyses/Encoding/encodinggraph.cc
@@ -6,11 +6,23 @@
 #include "set.h"
 #include "csolver.h"
 #include "tunable.h"
+#include "qsort.h"
 
 EncodingGraph::EncodingGraph(CSolver * _solver) :
        solver(_solver) {
-       
+}
 
+int sortEncodingEdge(const void * p1, const void *p2) {
+       const EncodingEdge * e1 = * (const EncodingEdge **) p1;
+       const EncodingEdge * e2 = * (const EncodingEdge **) p2;
+       uint64_t v1 = e1->getValue();
+       uint64_t v2 = e2->getValue();
+       if (v1 < v2)
+               return 1;
+       else if (v1 == v2)
+               return 0;
+       else
+               return -1;
 }
 
 void EncodingGraph::buildGraph() {
@@ -28,6 +40,7 @@ void EncodingGraph::buildGraph() {
                        ASSERT(0);
                }
        }
+       bsdqsort(edgeVector.expose(), edgeVector.getSize(), sizeof(EncodingEdge *), sortEncodingEdge);
 }
 
 void EncodingGraph::mergeNodes(EncodingNode *first, EncodingNode *second) {
@@ -120,6 +133,66 @@ void EncodingGraph::processPredicate(BooleanPredicate *b) {
        }
 }
 
+uint convertSize(uint cost) {
+       cost = 1.2 * cost; // fudge factor
+       return NEXTPOW2(cost);
+}
+
+void EncodingGraph::decideEdges() {
+       uint size=edgeVector.getSize();
+       for(uint i=0; i<size; i++) {
+               EncodingEdge *ee = edgeVector.get(i);
+               if (ee->encoding != EDGE_UNASSIGNED)
+                       continue;
+               
+               uint64_t eeValue = ee->getValue();
+               if (eeValue == 0)
+                       return;
+               EncodingNode *left = ee->left;
+               EncodingNode *right = ee->right;
+               EncodingSubGraph *leftGraph = graphMap.get(left);
+               EncodingSubGraph *rightGraph = graphMap.get(right);
+               if (leftGraph == NULL && rightGraph !=NULL) {
+                       EncodingNode *tmp = left; left=right; right=tmp;
+                       EncodingSubGraph *tmpsg = leftGraph; leftGraph = rightGraph; rightGraph = tmpsg;
+               }
+
+               uint leftSize=0, rightSize=0, newSize=0;
+               uint64_t totalCost=0;
+               if (leftGraph == NULL && rightGraph == NULL) {
+                       leftSize=convertSize(left->getSize());
+                       rightSize=convertSize(right->getSize());
+                       newSize=convertSize(left->s->getUnionSize(right->s));
+                       newSize=(leftSize > newSize) ? leftSize: newSize;
+                       newSize=(rightSize > newSize) ? rightSize: newSize;
+                       totalCost = (newSize - leftSize) * left->elements.getSize() +
+                               (newSize - rightSize) * right->elements.getSize();
+               } else if (leftGraph != NULL && rightGraph == NULL) {
+                       leftSize=convertSize(leftGraph->encodingSize);
+                       rightSize=convertSize(right->getSize());
+                       newSize=convertSize(leftGraph->estimateNewSize(right));
+                       newSize=(leftSize > newSize) ? leftSize: newSize;
+                       newSize=(rightSize > newSize) ? rightSize: newSize;
+                       totalCost = (newSize - leftSize) * leftGraph->numElements +
+                               (newSize - rightSize) * right->elements.getSize();
+               } else {
+                       //Neither are null
+                       leftSize=convertSize(leftGraph->encodingSize);
+                       rightSize=convertSize(rightGraph->encodingSize);
+                       newSize=convertSize(leftGraph->estimateNewSize(rightGraph));
+                       newSize=(leftSize > newSize) ? leftSize: newSize;
+                       newSize=(rightSize > newSize) ? rightSize: newSize;
+                       totalCost = (newSize - leftSize) * leftGraph->numElements +
+                               (newSize - rightSize) * rightGraph->numElements;
+               }
+               double conversionfactor = 0.5;
+               if ((totalCost * conversionfactor) < eeValue) {
+                       //add the edge
+                       mergeNodes(left, right);
+               }
+       }
+}
+
 static TunableDesc EdgeEncodingDesc(EDGE_UNASSIGNED, EDGE_MATCH, EDGE_UNASSIGNED);
 
 EncodingEdge * EncodingGraph::getEdge(EncodingNode *left, EncodingNode *right, EncodingNode *dst) {
@@ -134,22 +207,36 @@ EncodingEdge * EncodingGraph::getEdge(EncodingNode *left, EncodingNode *right, E
                        v2=v1;
                        v1=tmp;
                }
-               result->setEncoding((EdgeEncodingType)solver->getTuner()->getVarTunable(v1, v2, EDGEENCODING, &EdgeEncodingDesc));
+
+               if ((left != NULL && left->encoding==BINARYINDEX) &&
+                               (right != NULL) && right->encoding==BINARYINDEX) {
+                       EdgeEncodingType type=(EdgeEncodingType)solver->getTuner()->getVarTunable(v1, v2, EDGEENCODING, &EdgeEncodingDesc);
+                       result->setEncoding(type);
+                       if (type == EDGE_MATCH) {
+                               mergeNodes(left, right);
+                       }
+               }
                edgeMap.put(result, result);
+               edgeVector.push(result);
+               if (left != NULL)
+                       left->edges.add(result);
+               if (right != NULL)
+                       right->edges.add(result);
+               if (dst != NULL)
+                       dst->edges.add(result);
        }
        return result;
 }
 
 EncodingNode::EncodingNode(Set *_s) :
-       s(_s),
-       numElements(0) {
+       s(_s) {
 }
 
-uint EncodingNode::getSize() {
+uint EncodingNode::getSize() const {
        return s->getSize();
 }
 
-VarType EncodingNode::getType() {
+VarType EncodingNode::getType() const {
        return s->getType();
 }
 
@@ -166,8 +253,6 @@ EncodingNode * EncodingGraph::createNode(Element *e) {
                encodingMap.put(s, n);
        }
        n->addElement(e);
-       if (discovered.add(e))
-               n->numElements++;
        return n;
 }
 
@@ -206,47 +291,64 @@ bool equalsEncodingEdge(EncodingEdge *e1, EncodingEdge *e2) {
        return e1->left == e2->left && e1->right == e2->right && e1->dst == e2->dst;
 }
 
-EncodingSubGraph::EncodingSubGraph() {
+uint64_t EncodingEdge::getValue() const {
+       uint lSize = (left != NULL) ? left->getSize() : 1;
+       uint rSize = (right != NULL) ? right->getSize() : 1;
+       uint min = (lSize < rSize) ? lSize : rSize;
+       return numEquals * min + numComparisons * lSize * rSize;
 }
 
-void EncodingSubGraph::addNode(EncodingNode *n) {
-       nodes.add(n);
-       Set *s=n->s;
-       uint size=s->getSize();
-       for(uint i=0; i<size; i++) {
-               uint64_t val=s->getElement(i);
-               values.add(val);
-       }
+EncodingSubGraph::EncodingSubGraph() :
+       encodingSize(0),
+       numElements(0) {
 }
 
-SetIteratorEncodingNode * EncodingSubGraph::nodeIterator() {
-       return nodes.iterator();
+uint EncodingSubGraph::estimateNewSize(EncodingSubGraph *sg) {
+       uint newSize=0;
+       SetIteratorEncodingNode * nit = sg->nodes.iterator();
+       while(nit->hasNext()) {
+               EncodingNode *en = nit->next();
+               uint size=estimateNewSize(en);
+               if (size > newSize)
+                       newSize = size;
+       }
+       delete nit;
+       return newSize;
 }
 
-uint EncodingSubGraph::computeIntersection(Set *s) {
-       uint intersect=0;
-       uint size=s->getSize();
-       for(uint i=0; i<size; i++) {
-               uint64_t val=s->getElement(i);
-               if (values.contains(val))
-                       intersect++;
+uint EncodingSubGraph::estimateNewSize(EncodingNode *n) {
+       SetIteratorEncodingEdge * eeit = n->edges.iterator();
+       uint newsize=n->getSize();
+       while(eeit->hasNext()) {
+               EncodingEdge * ee = eeit->next();
+               if (ee->left != NULL && ee->left != n && nodes.contains(ee->left)) {
+                       uint intersectSize = n->s->getUnionSize(ee->left->s);
+                       if (intersectSize > newsize)
+                               newsize = intersectSize;
+               }
+               if (ee->right != NULL && ee->right != n && nodes.contains(ee->right)) {
+                       uint intersectSize = n->s->getUnionSize(ee->right->s);
+                       if (intersectSize > newsize)
+                               newsize = intersectSize;
+               }
+               if (ee->dst != NULL && ee->dst != n && nodes.contains(ee->dst)) {
+                       uint intersectSize = n->s->getUnionSize(ee->dst->s);
+                       if (intersectSize > newsize)
+                               newsize = intersectSize;
+               }
        }
-       return intersect;
+       delete eeit;
+       return newsize;
 }
 
-uint EncodingSubGraph::computeIntersection(EncodingSubGraph *g) {
-       if (g->values.getSize() > values.getSize()) {
-               //iterator over smaller set
-               return g->computeIntersection(this);
-       }
-       
-       uint intersect=0;
-       SetIterator64Int * iter=g->values.iterator();
-       while(iter->hasNext()) {
-               uint64_t val=iter->next();
-               if (values.contains(val))
-                       intersect++;
-       }
-       delete iter;
-       return intersect;
+void EncodingSubGraph::addNode(EncodingNode *n) {
+       nodes.add(n);
+       uint newSize=estimateNewSize(n);
+       numElements += n->elements.getSize();
+       if (newSize > encodingSize)
+               encodingSize=newSize;
+}
+
+SetIteratorEncodingNode * EncodingSubGraph::nodeIterator() {
+       return nodes.iterator();
 }

diff --git a/src/ASTAnalyses/Encoding/encodinggraph.h b/src/ASTAnalyses/Encoding/encodinggraph.h
index 4057dd2ed7c10115081320768bf04d0fa150dd43..f452dac2fc7660940bed0fa351695ec0abdd3bbd 100644 (file)
--- a/src/ASTAnalyses/Encoding/encodinggraph.h
+++ b/src/ASTAnalyses/Encoding/encodinggraph.h
@@ -11,6 +11,9 @@ class EncodingSubGraph;
 typedef Hashtable<EncodingEdge *, EncodingEdge *, uintptr_t, PTRSHIFT, hashEncodingEdge, equalsEncodingEdge> HashtableEdge;
 typedef Hashset<EncodingNode *, uintptr_t, PTRSHIFT> HashsetEncodingNode;
 typedef SetIterator<EncodingNode *, uintptr_t, PTRSHIFT> SetIteratorEncodingNode;
+typedef Hashset<EncodingEdge *, uintptr_t, PTRSHIFT> HashsetEncodingEdge;
+typedef SetIterator<EncodingEdge *, uintptr_t, PTRSHIFT> SetIteratorEncodingEdge;
+
 typedef Hashtable<EncodingNode *, EncodingSubGraph *, uintptr_t, PTRSHIFT> HashtableNodeToSubGraph;
 
 class EncodingGraph {
@@ -23,10 +26,11 @@ class EncodingGraph {
        CSolver * solver;
        HashtableEncoding encodingMap;
        HashtableEdge edgeMap;
+       Vector<EncodingEdge *> edgeVector;
        HashsetElement discovered;
        HashtableNodeToSubGraph graphMap;
 
-       
+       void decideEdges();
        void mergeNodes(EncodingNode *first, EncodingNode *second);
        void processElement(Element *e);
        void processFunction(ElementFunction *f);
@@ -39,15 +43,15 @@ class EncodingNode {
  public:
        EncodingNode(Set *_s);
        void addElement(Element *e);
-       uint getSize();
-       VarType getType();
+       uint getSize() const;
+       VarType getType() const;
        void setEncoding(ElementEncodingType e) {encoding=e;}
        
        CMEMALLOC;
  private:
        Set *s;
        HashsetElement elements;
-       uint numElements;
+       HashsetEncodingEdge edges;
        ElementEncodingType encoding;
        friend class EncodingGraph;
        friend class EncodingSubGraph;
@@ -58,13 +62,17 @@ class EncodingSubGraph {
        EncodingSubGraph();
        void addNode(EncodingNode *n);
        SetIteratorEncodingNode * nodeIterator();
-       uint computeIntersection(Set *s);
-       uint computeIntersection(EncodingSubGraph *g);
        
        CMEMALLOC;
  private:
+       uint estimateNewSize(EncodingNode *n);
+       uint estimateNewSize(EncodingSubGraph *sg);
+
        HashsetEncodingNode nodes;
-       Hashset64Int values;
+       uint encodingSize;
+       uint numElements;
+
+       friend class EncodingGraph;
 };
 
 enum EdgeEncodingType { EDGE_UNASSIGNED, EDGE_BREAK, EDGE_MATCH};
@@ -75,6 +83,7 @@ class EncodingEdge {
        EncodingEdge(EncodingNode *_l, EncodingNode *_r);
        EncodingEdge(EncodingNode *_l, EncodingNode *_r, EncodingNode *_d);
        void setEncoding(EdgeEncodingType e) {encoding=e;}
+       uint64_t getValue() const;
        CMEMALLOC;
        
  private:
@@ -88,6 +97,7 @@ class EncodingEdge {
        friend uint hashEncodingEdge(EncodingEdge *edge);
        friend bool equalsEncodingEdge(EncodingEdge *e1, EncodingEdge *e2);
        friend class EncodingGraph;
+       friend class EncodingSubGraph;
 };
 
 #endif

diff --git a/src/Collections/array.h b/src/Collections/array.h
index 496bdc65613e0586d2ad7de75bff3c8a7ab05422..03d83cd34672f4b83fa92b1f1d0857ac63ac7a46 100644 (file)
--- a/src/Collections/array.h
+++ b/src/Collections/array.h
@@ -27,7 +27,7 @@ public:
                }
        }
 
-       type get(uint index) {
+       type get(uint index) const {
                return array[index];
        }
 
@@ -35,7 +35,7 @@ public:
                array[index] = item;
        }
 
-       uint getSize() {
+       uint getSize() const {
                return size;
        }
 

diff --git a/src/Collections/cppvector.h b/src/Collections/cppvector.h
index e9164df61bdbe6426fb53093fd0016bae922e82f..2d4cc1956df10579e362966c84371f4f34d5c63f 100644 (file)
--- a/src/Collections/cppvector.h
+++ b/src/Collections/cppvector.h
@@ -24,7 +24,7 @@ public:
                size--;
        }
 
-       type last() {
+       type last() const {
                return array[size - 1];
        }
 
@@ -49,7 +49,7 @@ public:
                array[size++] = item;
        }
 
-       type get(uint index) {
+       type get(uint index) const {
                return array[index];
        }
 
@@ -63,7 +63,7 @@ public:
                array[index] = item;
        }
 
-       uint getSize() {
+       uint getSize() const {
                return size;
        }
 

diff --git a/src/Collections/hashset.h b/src/Collections/hashset.h
index cdba3b2d970e16352e95264db403a8245fa08ec1..13edbf95895e589d88fb4d548e575e7cf677408c 100644 (file)
--- a/src/Collections/hashset.h
+++ b/src/Collections/hashset.h
@@ -205,11 +205,11 @@ public:
                return true;
        }
 
-       unsigned int getSize() {
+       unsigned int getSize() const {
                return table->getSize();
        }
 
-       bool isEmpty() {
+       bool isEmpty() const {
                return getSize() == 0;
        }
 

diff --git a/src/Collections/vector.h b/src/Collections/vector.h
index ac32d853d7945f5762e795b5df8292a215d4c569..58e7abd3a6d6f94d9782e9aaeb77ebf558ee176a 100644 (file)
--- a/src/Collections/vector.h
+++ b/src/Collections/vector.h
@@ -81,7 +81,7 @@
        void setVector ## name(Vector ## name * vector, uint index, type item) { \
                vector->array[index] = item;                                          \
        }                                                                     \
-       uint getSizeVector ## name(Vector ## name * vector) {                  \
+       uint getSizeVector ## name(const Vector ## name * vector) {                                             \
                return vector->size;                                                \
        }                                                                     \
        void deleteVector ## name(Vector ## name * vector) {                     \