Robust/src/Analysis/Locality/DCWrapper.java

   1 package Analysis.Locality;
   2 import Analysis.Liveness;
   3 import Analysis.ReachingDefs;
   4 import Analysis.Loops.DomTree;
   5 import IR.State;
   6 import IR.MethodDescriptor;
   7 import IR.TypeDescriptor;
   8 import IR.FieldDescriptor;
   9 import IR.Flat.*;
  10 import Analysis.Loops.GlobalFieldType;
  11 import java.util.HashSet;
  12 import java.util.Hashtable;
  13 import java.util.Set;
  14 import java.util.List;
  15 import java.util.Arrays;
  16 import java.util.Stack;
  17 import java.util.Iterator;
  18
  19 public class DCWrapper {
  20   DelayComputation delaycomp;
  21   State state;
  22   LocalityAnalysis locality;
  23   TypeAnalysis typeanalysis;
  24   GlobalFieldType gft;
  25
  26   public DCWrapper(LocalityAnalysis locality, State state, TypeAnalysis typeanalysis, GlobalFieldType gft) {
  27     delaycomp=new DelayComputation(locality, state, typeanalysis, gft);
  28     delaycomp.doAnalysis();
  29     this.state=state;
  30     this.locality=locality;
  31     this.typeanalysis=typeanalysis;
  32     this.gft=gft;
  33     Set<LocalityBinding> localityset=locality.getLocalityBindings();
  34     for(Iterator<LocalityBinding> lbit=localityset.iterator();lbit.hasNext();) {
  35       processlb(lbit.next());
  36     }
  37   }
  38
  39   Hashtable<LocalityBinding, Set<FlatNode>> transmap=new Hashtable<LocalityBinding, Set<FlatNode>>();
  40   Hashtable<LocalityBinding, Set<FlatNode>> recordmap=new Hashtable<LocalityBinding, Set<FlatNode>>();
  41   Hashtable<LocalityBinding, Set<FlatNode>> othermap=new Hashtable<LocalityBinding, Set<FlatNode>>();
  42   Hashtable<LocalityBinding, Set<FlatNode>> notreadymap=new Hashtable<LocalityBinding, Set<FlatNode>>();
  43   Hashtable<LocalityBinding, HashSet<FlatNode>> cannotdelaymap=new Hashtable<LocalityBinding, HashSet<FlatNode>>();
  44   Hashtable<LocalityBinding, Set<FlatNode>> derefmap=new Hashtable<LocalityBinding, Set<FlatNode>>();
  45
  46   public DiscoverConflicts getConflicts() {
  47     DiscoverConflicts dc=new DiscoverConflicts(locality, state, typeanalysis, cannotdelaymap, false, false, state.READSET?gft:null);
  48     dc.doAnalysis();
  49     return dc;
  50   }
  51
  52   public Hashtable<LocalityBinding, HashSet<FlatNode>> getCannotDelayMap() {
  53     return cannotdelaymap;
  54   }
  55
  56   public boolean needsFission(LocalityBinding lb, FlatAtomicEnterNode faen) {
  57     return transmap.get(lb).contains(faen);
  58   }
  59
  60   public Set<TempDescriptor> liveinto(LocalityBinding lb, FlatAtomicEnterNode faen, Set<FlatNode> recordset) {
  61     return delaycomp.liveinto(lb, faen, recordset);
  62   }
  63
  64   public Set<TempDescriptor> alltemps(LocalityBinding lb, FlatAtomicEnterNode faen, Set<FlatNode> recordset) {
  65     return delaycomp.alltemps(lb, faen, recordset);
  66   }
  67
  68   public Set<TempDescriptor> liveout(LocalityBinding lb, FlatAtomicEnterNode faen) {
  69     return delaycomp.liveout(lb, faen);
  70   }
  71
  72   public Set<TempDescriptor> liveoutvirtualread(LocalityBinding lb, FlatAtomicEnterNode faen) {
  73     return delaycomp.liveoutvirtualread(lb, faen);
  74   }
  75
  76   private static HashSet<FlatNode> intersect(Set<FlatNode> a, Set<FlatNode> b) {
  77     HashSet<FlatNode> intersect=new HashSet(b);
  78     intersect.retainAll(a);
  79     return intersect;
  80   }
  81
  82   public Set<FlatNode> getDeref(LocalityBinding lb) {
  83     return derefmap.get(lb);
  84   }
  85
  86   public Set<FlatNode> getNotReady(LocalityBinding lb) {
  87     return notreadymap.get(lb);
  88   }
  89
  90   public Set<FlatNode> getCannotDelay(LocalityBinding lb) {
  91     return cannotdelaymap.get(lb);
  92   }
  93
  94   public Set<FlatNode> getOther(LocalityBinding lb) {
  95     return othermap.get(lb);
  96   }
  97
  98   public Set<FlatNode> livecode(LocalityBinding lb) {
  99     return recordmap.get(lb);
 100   }
 101
 102   private void processlb(LocalityBinding lb) {
 103     transmap.put(lb, new HashSet<FlatNode>());
 104     if (lb.isAtomic()||!lb.getHasAtomic())
 105       return;
 106
 107     Set<FlatNode> recordset=delaycomp.livecode(lb);
 108     Set<FlatNode> cannotdelay=delaycomp.getCannotDelay(lb);
 109     Set<FlatNode> otherset=delaycomp.getOther(lb);
 110     Set<FlatNode> notreadyset=delaycomp.getNotReady(lb);
 111     Set<FlatNode> derefset=(state.STMARRAY&&!state.DUALVIEW)?delaycomp.getDeref(lb):null;
 112     Set<FlatNode> checkset=new HashSet<FlatNode>();
 113     checkset.addAll(cannotdelay);
 114     checkset.addAll(otherset);
 115
 116     Set<FlatNode> nrecordset=new HashSet<FlatNode>();
 117     HashSet<FlatNode> ncannotdelay=new HashSet<FlatNode>();
 118     Set<FlatNode> notherset=new HashSet<FlatNode>();
 119     Set<FlatNode> nnotready=new HashSet<FlatNode>();
 120     Set<FlatNode> nderef=new HashSet<FlatNode>();
 121
 122     recordmap.put(lb, nrecordset);
 123     cannotdelaymap.put(lb, ncannotdelay);
 124     notreadymap.put(lb, nnotready);
 125     othermap.put(lb, notherset);
 126     derefmap.put(lb, nderef);
 127
 128     FlatMethod fm=state.getMethodFlat(lb.getMethod());
 129     for(Iterator<FlatNode> fnit=fm.getNodeSet().iterator();fnit.hasNext();) {
 130       FlatNode fn=fnit.next();
 131       if (fn.kind()==FKind.FlatAtomicEnterNode&&
 132           locality.getAtomic(lb).get(fn.getPrev(0)).intValue()==0) {
 133         Set<FlatNode> transSet=computeTrans(lb, fn);
 134         Set<FlatNode> tCheckSet=intersect(checkset, transSet);
 135         Set<FlatNode> tRecordSet=intersect(recordset, transSet);
 136         Set<FlatNode> tOtherSet=intersect(otherset, transSet);
 137         Set<FlatNode> tNotReadySet=intersect(notreadyset, transSet);
 138         HashSet<FlatNode> tCannotDelay=intersect(cannotdelay, transSet);
 139         Set<FlatNode> tderef=(state.STMARRAY&&!state.DUALVIEW)?intersect(derefset, transSet):null;
 140
 141         if (checkSet(fn, tCheckSet, tRecordSet, lb)) {
 142           //We will convert this one
 143           nrecordset.addAll(tRecordSet);
 144           notherset.addAll(tOtherSet);
 145           nnotready.addAll(tNotReadySet);
 146           ncannotdelay.addAll(tCannotDelay);
 147           if (state.STMARRAY&&!state.DUALVIEW)
 148             nderef.addAll(tderef);
 149           transmap.get(lb).add(fn);
 150         } else {
 151           ncannotdelay.addAll(transSet);
 152         }
 153         if (!lwmap.containsKey(lb))
 154           lwmap.put(lb, new HashSet<FlatNode>());
 155         lwmap.get(lb).add(fn);
 156       } else {
 157         if (locality.getAtomic(lb).get(fn).intValue()==0)
 158           ncannotdelay.add(fn);
 159       }
 160     }
 161   }
 162
 163   Hashtable<LocalityBinding, Set<FlatNode>> lwmap=new Hashtable<LocalityBinding, Set<FlatNode>>();
 164   Hashtable<LocalityBinding, Set<FlatNode>> optmap=new Hashtable<LocalityBinding, Set<FlatNode>>();
 165
 166   public boolean lightweightTrans(LocalityBinding lb, FlatNode fn) {
 167     return lwmap.get(lb).contains(fn);
 168   }
 169
 170   public boolean optimizeTrans(LocalityBinding lb, FlatNode fn) {
 171     return optmap.get(lb).contains(fn);
 172   }
 173
 174   private boolean checkSet(FlatNode faen, Set<FlatNode> checkset, Set<FlatNode> recordset, LocalityBinding lb) {
 175     if (!optmap.containsKey(lb)) {
 176       optmap.put(lb, new HashSet<FlatNode>());
 177     }
 178     DiscoverConflicts dc=delaycomp.getConflicts();
 179     for(Iterator<FlatNode> fnit=checkset.iterator();fnit.hasNext();) {
 180       FlatNode fn=fnit.next();
 181       //needs transread
 182       if (!state.READSET&&dc.getNeedTrans(lb, fn)||state.READSET&&dc.getNeedWriteTrans(lb, fn)||fn.kind()==FKind.FlatCall) {
 183         System.out.println("False because"+fn);
 184         if (!state.HYBRID)
 185           return true;
 186         return false;
 187       }
 188     }
 189     optmap.get(lb).add(faen);
 190     return true;
 191   }
 192
 193   private Set<FlatNode> computeTrans(LocalityBinding lb, FlatNode faen) {
 194     HashSet<FlatNode> transSet=new HashSet<FlatNode>();
 195     HashSet<FlatNode> toProcess=new HashSet<FlatNode>();
 196     toProcess.add(faen);
 197     while(!toProcess.isEmpty()) {
 198       FlatNode fn=toProcess.iterator().next();
 199       toProcess.remove(fn);
 200       transSet.add(fn);
 201       if (locality.getAtomic(lb).get(fn).intValue()==0)
 202         continue;
 203       for(int i=0;i<fn.numNext();i++) {
 204         if (!transSet.contains(fn.getNext(i)))
 205           toProcess.add(fn.getNext(i));
 206       }
 207     }
 208     return transSet;
 209   }
 210 }