#include "iterator.h"
#include "element.h"
#include "function.h"
+#include "predicate.h"
+#include "set.h"
EncodingGraph::EncodingGraph(CSolver * _solver) :
solver(_solver) {
Function *f=ef->getFunction();
if (f->type==OPERATORFUNC) {
FunctionOperator *fo=(FunctionOperator*)f;
- ArithOp op=fo->op;
+ ASSERT(ef->inputs.getSize() == 2);
+ EncodingNode *left=createNode(ef->inputs.get(0));
+ EncodingNode *right=createNode(ef->inputs.get(1));
+ if (left == NULL && right == NULL)
+ return;
+ EncodingNode *dst=createNode(ef);
+ EncodingEdge *edge=getEdge(left, right, dst);
+ edge->numArithOps++;
}
}
void EncodingGraph::processPredicate(BooleanPredicate *b) {
+ Predicate *p=b->getPredicate();
+ if (p->type==OPERATORPRED) {
+ PredicateOperator *po=(PredicateOperator *)p;
+ ASSERT(b->inputs.getSize()==2);
+ EncodingNode *left=createNode(b->inputs.get(0));
+ EncodingNode *right=createNode(b->inputs.get(1));
+ if (left == NULL || right == NULL)
+ return;
+ EncodingEdge *edge=getEdge(left, right, NULL);
+ CompOp op=po->getOp();
+ switch(op) {
+ case SATC_EQUALS:
+ edge->numEquals++;
+ break;
+ case SATC_LT:
+ case SATC_LTE:
+ case SATC_GT:
+ case SATC_GTE:
+ edge->numComparisons++;
+ break;
+ default:
+ ASSERT(0);
+ }
+ }
+}
+
+EncodingEdge * EncodingGraph::getEdge(EncodingNode *left, EncodingNode *right, EncodingNode *dst) {
+ EncodingEdge e(left, right, dst);
+ EncodingEdge *result = edgeMap.get(&e);
+ if (result == NULL) {
+ result=new EncodingEdge(left, right, dst);
+ edgeMap.put(result, result);
+ }
+ return result;
+}
+
+EncodingNode::EncodingNode(Set *_s) :
+ s(_s),
+ numElements(0) {
+}
+uint EncodingNode::getSize() {
+ return s->getSize();
}
EncodingNode * EncodingGraph::createNode(Element *e) {
+ if (e->type == ELEMCONST)
+ return NULL;
Set *s = e->getRange();
EncodingNode *n = encodingMap.get(s);
if (n == NULL) {
encodingMap.put(s, n);
}
n->addElement(e);
+ if (discovered.add(e))
+ n->numElements++;
return n;
}
EncodingEdge::EncodingEdge(EncodingNode *_l, EncodingNode *_r) :
left(_l),
right(_r),
- dst(NULL)
+ dst(NULL),
+ numArithOps(0),
+ numEquals(0),
+ numComparisons(0)
{
}
EncodingEdge::EncodingEdge(EncodingNode *_left, EncodingNode *_right, EncodingNode *_dst) :
left(_left),
right(_right),
- dst(_dst)
+ dst(_dst),
+ numArithOps(0),
+ numEquals(0),
+ numComparisons(0)
{
}