src/Translator/decomposeorderresolver.cc

   1
   2 /*
   3  * File:   DecomposeOrderResolver.cc
   4  * Author: hamed
   5  *
   6  * Created on September 1, 2017, 10:36 AM
   7  */
   8
   9 #include "decomposeorderresolver.h"
  10 #include "order.h"
  11 #include "ordernode.h"
  12 #include "ordergraph.h"
  13
  14 DecomposeOrderResolver::DecomposeOrderResolver(Order *_order) :
  15         graph(NULL),
  16         order(_order)
  17 {
  18 }
  19
  20 DecomposeOrderResolver::~DecomposeOrderResolver() {
  21         if (graph != NULL)
  22                 delete graph;
  23         edges.resetAndDelete();
  24 }
  25
  26 void DecomposeOrderResolver::mustOrderEdge(uint64_t first, uint64_t second) {
  27         DOREdge edge(first, second, 0, first, second);
  28         DOREdge *oldedge = edges.get(&edge);
  29         if (oldedge != NULL) {
  30                 oldedge->mustbetrue = true;
  31         } else {
  32                 DOREdge *newedge = new DOREdge(first, second, 0, first, second);
  33                 newedge->mustbetrue = true;
  34                 edges.add(newedge);
  35         }
  36 }
  37
  38 void DecomposeOrderResolver::remapEdge(uint64_t first, uint64_t second, uint64_t newfirst, uint64_t newsecond) {
  39         DOREdge edge(first, second, 0, first, second);
  40         DOREdge *oldedge = edges.get(&edge);
  41         if (oldedge != NULL) {
  42                 edges.remove(oldedge);
  43                 oldedge->newfirst = newfirst;
  44                 oldedge->newsecond = newsecond;
  45                 edges.add(oldedge);
  46         } else {
  47                 DOREdge *newedge = new DOREdge(first, second, 0, newfirst, newsecond);
  48                 edges.add(newedge);
  49         }
  50 }
  51
  52 void DecomposeOrderResolver::setEdgeOrder(uint64_t first, uint64_t second, uint sccNum) {
  53         DOREdge edge(first, second, 0, first, second);
  54         DOREdge *oldedge = edges.get(&edge);
  55         if (oldedge != NULL) {
  56                 oldedge->orderindex = sccNum;
  57         } else {
  58                 DOREdge *newedge = new DOREdge(first, second, sccNum, first, second);
  59                 edges.add(newedge);
  60         }
  61         /* Also fix up reverse edge if it exists */
  62         DOREdge revedge(second, first, 0, second, first);
  63         oldedge = edges.get(&revedge);
  64         if (oldedge != NULL) {
  65                 oldedge->orderindex = sccNum;
  66         }
  67 }
  68
  69 void DecomposeOrderResolver::setOrder(uint sccNum, Order *neworder) {
  70         orders.setExpand(sccNum, neworder);
  71 }
  72
  73 Order *DecomposeOrderResolver::getOrder(uint sccNum) {
  74         Order *neworder = NULL;
  75         if (orders.getSize() > sccNum)
  76                 neworder = orders.get(sccNum);
  77         return neworder;
  78 }
  79
  80 void DecomposeOrderResolver::buildGraph() {
  81         graph = new OrderGraph(order);
  82         SetIteratorDOREdge *iterator = edges.iterator();
  83         while (iterator->hasNext()) {
  84                 DOREdge *doredge = iterator->next();
  85                 if (doredge->mustbetrue) {
  86                         graph->addEdge(doredge->origfirst, doredge->origsecond);
  87                         if (doredge->newfirst != doredge->origfirst || doredge->newsecond != doredge->origsecond) {
  88                                 graph->addEdge(doredge->newfirst, doredge->newsecond);
  89                         }
  90                 } else if (doredge->orderindex != 0) {
  91                         Order *suborder = orders.get(doredge->orderindex);
  92                         bool isEdge = suborder->encoding.resolver->resolveOrder(doredge->newfirst, doredge->newsecond);
  93                         if (isEdge)
  94                                 graph->addEdge(doredge->origfirst, doredge->origsecond);
  95                         else if (order->type == SATC_TOTAL)
  96                                 graph->addEdge(doredge->origsecond, doredge->origfirst);
  97                 }
  98         }
  99         delete iterator;
 100         if (order->type == SATC_TOTAL) {
 101                 graph->computeStronglyConnectedComponentGraph();
 102         }
 103 }
 104
 105 bool DecomposeOrderResolver::resolveOrder(uint64_t first, uint64_t second) {
 106         if (graph == NULL)
 107                 buildGraph();
 108
 109         OrderNode *from = graph->lookupOrderNodeFromOrderGraph(first);
 110         if (from == NULL) {
 111                 ASSERT(order->type != SATC_TOTAL);
 112                 return false;
 113         }
 114         OrderNode *to = graph->lookupOrderNodeFromOrderGraph(second);
 115         if (to == NULL) {
 116                 ASSERT(order->type != SATC_TOTAL);
 117                 return false;
 118         }
 119         switch (order->type) {
 120         case SATC_TOTAL:
 121                 return from->sccNum < to->sccNum;
 122         case SATC_PARTIAL:
 123                 return resolvePartialOrder(from, to);
 124         default:
 125                 ASSERT(0);
 126         }
 127 }
 128
 129 bool DecomposeOrderResolver::resolvePartialOrder(OrderNode *first, OrderNode *second) {
 130         if (first->sccNum > second->sccNum) {
 131                 return false;
 132         } else {
 133                 return graph->isTherePath(first, second);
 134         }
 135 }
 136