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         uint size=edges.getSize();
  24         edges.resetAndDelete();
  25 }
  26
  27 void DecomposeOrderResolver::mustOrderEdge(uint64_t first, uint64_t second) {
  28         DOREdge edge(first, second, 0, first, second);
  29         if (!edges.contains(&edge)) {
  30                 DOREdge *newedge=new DOREdge(first, second, 0, first, second);
  31                 edges.add(newedge);
  32         }
  33 }
  34
  35 void DecomposeOrderResolver::remapEdge(uint64_t first, uint64_t second, uint64_t newfirst, uint64_t newsecond) {
  36         DOREdge edge(first, second, 0, first, second);
  37         DOREdge *oldedge=edges.get(&edge);
  38         if (oldedge != NULL) {
  39                 edges.remove(oldedge);
  40                 oldedge->newfirst=newfirst;
  41                 oldedge->newsecond=newsecond;
  42                 edges.add(oldedge);
  43         } else {
  44                 DOREdge *newedge=new DOREdge(first, second, 0, newfirst, newsecond);
  45                 edges.add(newedge);
  46         }
  47 }
  48
  49 void DecomposeOrderResolver::setEdgeOrder(uint64_t first, uint64_t second, uint sccNum) {
  50         DOREdge edge(first, second, 0, first, second);
  51         DOREdge *oldedge=edges.get(&edge);
  52         if (oldedge != NULL) {
  53                 oldedge->orderindex=sccNum;
  54         } else {
  55                 DOREdge *newedge=new DOREdge(first, second, sccNum, first, second);
  56                 edges.add(newedge);
  57         }
  58 }
  59
  60 void DecomposeOrderResolver::setOrder(uint sccNum, Order *neworder) {
  61         orders.setExpand(sccNum, neworder);
  62 }
  63
  64 Order * DecomposeOrderResolver::getOrder(uint sccNum) {
  65         Order *neworder = NULL;
  66         if (orders.getSize() > sccNum)
  67                 neworder = orders.get(sccNum);
  68         return neworder;
  69 }
  70
  71 bool DecomposeOrderResolver::resolveOrder(uint64_t first, uint64_t second) {
  72         OrderNode *from = graph->lookupOrderNodeFromOrderGraph(first);
  73         ASSERT(from != NULL);
  74         OrderNode *to = graph->lookupOrderNodeFromOrderGraph(second);
  75         ASSERT(to != NULL);
  76         if (from->removed || to->removed) {
  77                 HashsetOrderNode fromset, toset;
  78                 //              processNode(&fromset, from, true);
  79                 //              processNode(&toset, to, false);
  80                 SetIteratorOrderNode *fromit=fromset.iterator();
  81                 while(fromit->hasNext()) {
  82                         OrderNode * nodefrom=fromit->next();
  83                         SetIteratorOrderNode *toit=toset.iterator();
  84                         while(toit->hasNext()) {
  85                                 OrderNode * nodeto=toit->next();
  86                                 if (resolveOrder(nodefrom->getID(), nodeto->getID())) {
  87                                         delete fromit;
  88                                         delete toit;
  89                                         return true;
  90                                 }
  91                         }
  92                         delete toit;
  93                 }
  94                 delete fromit;
  95                 return false;
  96         } else if (from->sccNum != to->sccNum) {
  97                 OrderEdge *edge = graph->lookupOrderEdgeFromOrderGraph(from, to);
  98                 switch (graph->getOrder()->type) {
  99                 case SATC_TOTAL:
 100                         return from->sccNum < to->sccNum;
 101                 case SATC_PARTIAL:
 102                         return resolvePartialOrder(from, to);
 103                 default:
 104                         ASSERT(0);
 105                 }
 106         } else {
 107                 Order *suborder = NULL;
 108                 // We should ask this query from the suborder ....
 109                 suborder = orders.get(from->sccNum);
 110                 ASSERT(suborder != NULL);
 111                 return suborder->encoding.resolver->resolveOrder(from->id, to->id);
 112         }
 113 }
 114
 115 bool DecomposeOrderResolver::resolvePartialOrder(OrderNode *first, OrderNode *second) {
 116         if (first->sccNum > second->sccNum) {
 117                 return false;
 118         } else {
 119                 return graph->isTherePath(first, second);
 120         }
 121
 122 }
 123