src/ASTTransform/elementopt.cc

   1 #include "elementopt.h"
   2 #include "csolver.h"
   3 #include "tunable.h"
   4 #include "iterator.h"
   5 #include "boolean.h"
   6 #include "element.h"
   7 #include "predicate.h"
   8
   9 ElementOpt::ElementOpt(CSolver *_solver)
  10         : Transform(_solver)
  11 {
  12 }
  13
  14 ElementOpt::~ElementOpt() {
  15 }
  16
  17 void ElementOpt::doTransform() {
  18         if (solver->getTuner()->getTunable(ELEMENTOPT, &onoff) == 0)
  19                 return;
  20
  21         SetIteratorBooleanEdge *iterator = solver->getConstraints();
  22         while (iterator->hasNext()) {
  23                 BooleanEdge constraint = iterator->next();
  24                 if (constraint->type == PREDICATEOP)
  25                         workList.push((BooleanPredicate *)constraint.getBoolean());
  26         }
  27         while (workList.getSize() != 0) {
  28                 BooleanPredicate * pred = workList.last(); workList.pop();
  29                 processPredicate(pred);
  30         }
  31         delete iterator;
  32 }
  33
  34 void ElementOpt::processPredicate(BooleanPredicate * pred) {
  35         uint numInputs = pred->inputs.getSize();
  36         if (numInputs != 2)
  37                 return;
  38
  39         Predicate * p = pred->getPredicate();
  40         if (p->type == TABLEPRED)
  41                         return;
  42
  43         PredicateOperator * pop = (PredicateOperator *) p;
  44         CompOp op = pop->getOp();
  45
  46         Element * left = pred->inputs.get(0);
  47         Element * right = pred->inputs.get(1);
  48
  49         if (left->type == ELEMCONST) {
  50                 Element * tmp = left;
  51                 left = right;
  52                 right = tmp;
  53                 op = flipOp(op);
  54         } else if (right->type != ELEMCONST)
  55                 return;
  56
  57         if (left->type !=ELEMSET)
  58                 return;
  59
  60         if (op == SATC_EQUALS) {
  61                 handlePredicateEquals(pred, (ElementSet *) left, (ElementConst *) right);
  62         } else {
  63                 handlePredicateInequality(pred, (ElementSet *) left, (ElementConst *) right);
  64         }
  65 }
  66
  67 void ElementOpt::handlePredicateEquals(BooleanPredicate *pred, ElementSet *left, ElementConst *right) {
  68         if (pred->isTrue()) {
  69                 replaceVarWithConst(pred, left, right);
  70         } else if (pred->isFalse()) {
  71
  72         } else ASSERT(0);
  73 }
  74
  75 void ElementOpt::handlePredicateInequality(BooleanPredicate *pred, ElementSet *left, ElementConst *right) {
  76
  77 }
  78
  79 void ElementOpt::replaceVarWithConst(BooleanPredicate * pred, ElementSet *var, ElementConst * value) {
  80         uint size = var->parents.getSize();
  81         for(uint i=0; i < size; i++) {
  82                 ASTNode * parent = var->parents.get(i);
  83                 if (parent->type == PREDICATEOP && pred != parent) {
  84                         BooleanPredicate * newpred = (BooleanPredicate *) parent;
  85                         for(uint j=0; j < newpred->inputs.getSize(); j++) {
  86                                 Element * e = newpred->inputs.get(j);
  87                                 if (e == var) {
  88                                         solver->boolMap.remove(newpred);
  89                                         newpred->inputs.set(j, value);
  90                                         solver->boolMap.put(newpred, newpred);
  91                                         workList.push(newpred);
  92                                         break;
  93                                 }
  94                         }
  95                 }
  96         }
  97 }