Robust/src/Analysis/MLP/ParentChildConflictsMap.java

   1 package Analysis.MLP;
   2
   3 import java.util.Enumeration;
   4 import java.util.HashSet;
   5 import java.util.Hashtable;
   6 import java.util.Iterator;
   7 import java.util.Set;
   8
   9 import Analysis.OwnershipAnalysis.AllocationSite;
  10 import Analysis.OwnershipAnalysis.HeapRegionNode;
  11 import Analysis.OwnershipAnalysis.ReferenceEdge;
  12 import Analysis.OwnershipAnalysis.TokenTupleSet;
  13 import IR.Flat.TempDescriptor;
  14
  15 public class ParentChildConflictsMap {
  16
  17         public static final Integer ACCESSIBLE = new Integer(1);
  18         public static final Integer INACCESSIBLE = new Integer(2);
  19
  20         private Hashtable<TempDescriptor, Integer> accessibleMap;
  21         private Hashtable<TempDescriptor, StallSite> stallMap;
  22         private Hashtable < ReferenceEdge, HashSet<StallTag> > stallEdgeMap;
  23         private boolean isAfterSESE;
  24
  25         public ParentChildConflictsMap() {
  26
  27                 accessibleMap = new Hashtable<TempDescriptor, Integer>();
  28                 stallMap = new Hashtable<TempDescriptor, StallSite>();
  29                 stallEdgeMap= new Hashtable < ReferenceEdge, HashSet<StallTag> >();
  30                 isAfterSESE=false;
  31         }
  32
  33         public void setIsAfterSESE(boolean after){
  34                 this.isAfterSESE=after;
  35         }
  36
  37         public boolean isAfterSESE(){
  38                 return isAfterSESE;
  39         }
  40
  41         public void clear(){
  42                 accessibleMap.clear();
  43                 stallMap.clear();
  44                 stallEdgeMap.clear();
  45         }
  46
  47         public void clearStallMap(){
  48                 stallMap.clear();
  49         }
  50
  51         public void makeAllInaccessible(){
  52
  53                 Set<TempDescriptor> keySet=accessibleMap.keySet();
  54                 for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
  55                         TempDescriptor key = (TempDescriptor) iterator.next();
  56                         accessibleMap.put(key, INACCESSIBLE);
  57                 }
  58
  59         }
  60
  61         public Hashtable < ReferenceEdge, HashSet<StallTag> > getStallEdgeMap(){
  62                 return stallEdgeMap;
  63         }
  64
  65         public void addStallEdge(ReferenceEdge edge, StallTag sTag){
  66
  67                 HashSet<StallTag> tagSet=stallEdgeMap.get(edge);
  68                 if(tagSet==null){
  69                         tagSet=new HashSet<StallTag>();
  70                 }
  71                 tagSet.add(sTag);
  72                 stallEdgeMap.put(edge, tagSet);
  73         }
  74
  75         public HashSet<StallTag> getStallTagByEdge(ReferenceEdge edge){
  76                 return stallEdgeMap.get(edge);
  77         }
  78
  79         public Hashtable<TempDescriptor, Integer> getAccessibleMap() {
  80                 return accessibleMap;
  81         }
  82
  83         public Hashtable<TempDescriptor, StallSite> getStallMap() {
  84                 return stallMap;
  85         }
  86
  87         public void addAccessibleVar(TempDescriptor td) {
  88                 accessibleMap.put(td, ACCESSIBLE);
  89         }
  90
  91         public void addInaccessibleVar(TempDescriptor td) {
  92                 accessibleMap.put(td, INACCESSIBLE);
  93         }
  94
  95         public void addStallSite(TempDescriptor td, HashSet<HeapRegionNode> heapSet, StallTag sTag, TempDescriptor tdA) {
  96                 StallSite stallSite=new StallSite(heapSet,sTag);
  97                 if(tdA!=null){
  98                         stallSite.setTdA(tdA);
  99                 }
 100                 stallMap.put(td, stallSite);
 101         }
 102
 103         public void addStallSite(TempDescriptor td, StallSite stallSite) {
 104                 stallMap.put(td, stallSite);
 105         }
 106
 107         public boolean hasStallSite(TempDescriptor td){
 108                 return stallMap.containsKey(td);
 109         }
 110
 111         public boolean isAccessible(TempDescriptor td) {
 112                 if (accessibleMap.containsKey(td)
 113                                 && accessibleMap.get(td).equals(ACCESSIBLE)) {
 114                         return true;
 115                 }
 116                 return false;
 117         }
 118
 119         public void contributeEffect(TempDescriptor td, String type, String field,
 120                         int effect) {
 121
 122                 StallSite stallSite = stallMap.get(td);
 123                 if (stallSite != null) {
 124                         stallSite.addEffect(type, field, effect);
 125                 }
 126
 127         }
 128
 129         public void merge(ParentChildConflictsMap newConflictsMap) {
 130
 131                 Hashtable<TempDescriptor, Integer> newAccessibleMap = newConflictsMap
 132                                 .getAccessibleMap();
 133                 Hashtable<TempDescriptor, StallSite> newStallMap = newConflictsMap
 134                                 .getStallMap();
 135
 136                 Set<TempDescriptor> keySet = newAccessibleMap.keySet();
 137                 for (Iterator<TempDescriptor> iterator = keySet.iterator(); iterator
 138                                 .hasNext();) {
 139                         TempDescriptor key = iterator.next();
 140
 141                         Integer newStatus = newAccessibleMap.get(key);
 142
 143                         // inaccessible is prior to accessible
 144                         Integer currentStatus = getAccessibleMap().get(key);
 145                         if (currentStatus != null && currentStatus == ACCESSIBLE
 146                                         && newStatus == INACCESSIBLE) {
 147                                 getAccessibleMap().put(key, INACCESSIBLE);
 148                         }else if(currentStatus == null && newStatus == ACCESSIBLE){
 149                                 getAccessibleMap().put(key, ACCESSIBLE);
 150                         }
 151                 }
 152
 153                 keySet = newStallMap.keySet();
 154                 for (Iterator<TempDescriptor> iterator = keySet.iterator(); iterator
 155                                 .hasNext();) {
 156                         TempDescriptor key = iterator.next();
 157
 158                         StallSite newStallSite = newStallMap.get(key);
 159                         StallSite currentStallSite = getStallMap().get(key);
 160
 161                         if(currentStallSite==null){
 162                                 currentStallSite=new StallSite();
 163                         }
 164
 165                         // handle effects
 166                         HashSet<Effect> currentEffectSet = currentStallSite.getEffectSet();
 167                         HashSet<Effect> newEffectSet = newStallSite.getEffectSet();
 168                         for (Iterator iterator2 = newEffectSet.iterator(); iterator2
 169                                         .hasNext();) {
 170                                 Effect effect = (Effect) iterator2.next();
 171                                 if (!currentEffectSet.contains(effect)) {
 172                                         currentEffectSet.add(effect);
 173                                 }
 174                         }
 175
 176                         // handle heap region
 177                         HashSet<HeapRegionNode> currentHRNSet = currentStallSite.getHRNSet();
 178                         HashSet<HeapRegionNode> newHRNSet = newStallSite.getHRNSet();
 179                         for (Iterator iterator2 = newHRNSet.iterator(); iterator2.hasNext();) {
 180                                 HeapRegionNode hrnID = (HeapRegionNode) iterator2.next();
 181                                 if (!currentHRNSet.contains(hrnID)) {
 182                                         currentHRNSet.add(hrnID);
 183                                 }
 184                         }
 185
 186                         // handle reachabilitySet
 187                         HashSet<TokenTupleSet> currentRSet=currentStallSite.getReachabilitySet();
 188                         HashSet<TokenTupleSet> newRSet=newStallSite.getReachabilitySet();
 189                         Iterator<TokenTupleSet> ttsIter=newRSet.iterator();
 190                         while(ttsIter.hasNext()){
 191                                 TokenTupleSet tokenTupleSet=(TokenTupleSet) ttsIter.next();
 192                                 currentRSet.add(tokenTupleSet);
 193                         }
 194 //                      ReachabilitySet currentRSet = currentStallSite.getReachabilitySet();
 195 //                      ReachabilitySet newRSet = newStallSite.getReachabilitySet();
 196 //                      Iterator<TokenTupleSet> ttsIter = newRSet.iterator();
 197 //                      while (ttsIter.hasNext()) {
 198 //                              TokenTupleSet tokenTupleSet = (TokenTupleSet) ttsIter.next();
 199 //                              currentRSet.add(tokenTupleSet);
 200 //                      }
 201
 202                         //handle allocationsite
 203                         HashSet<AllocationSite> currentAloc=currentStallSite.getAllocationSiteSet();
 204                         HashSet<AllocationSite> newAloc=newStallSite.getAllocationSiteSet();
 205                         currentAloc.addAll(newAloc);
 206
 207                         // handle related stall tags
 208                         HashSet<StallTag> currentStallTagSet=currentStallSite.getStallTagSet();
 209                         HashSet<StallTag> newStallTagSet=newStallSite.getStallTagSet();
 210                         currentStallTagSet.addAll(newStallTagSet);
 211
 212                         // reaching param idxs
 213                         HashSet<Integer> currentParamIdx=currentStallSite.getCallerParamIdxSet();
 214                         HashSet<Integer> newParamIdx=newStallSite.getCallerParamIdxSet();
 215                         currentParamIdx.addAll(newParamIdx);
 216
 217                         StallSite merged=new StallSite(currentEffectSet, currentHRNSet,
 218                                         currentRSet, currentAloc, currentStallTagSet,currentParamIdx);
 219
 220
 221                         getStallMap()
 222                                         .put(
 223                                                         key,
 224                                                         merged);
 225
 226                 }
 227
 228                 // merge edge mapping
 229
 230                 Hashtable<ReferenceEdge, HashSet<StallTag>> newStallEdgeMapping=newConflictsMap.getStallEdgeMap();
 231                 Set<ReferenceEdge> edgeSet=newStallEdgeMapping.keySet();
 232
 233                 for (Iterator iterator = edgeSet.iterator(); iterator.hasNext();) {
 234                         ReferenceEdge stallEdge = (ReferenceEdge) iterator.next();
 235                         HashSet<StallTag> newStallTagSet=newStallEdgeMapping.get(stallEdge);
 236                         HashSet<StallTag>currentStallTagSet=getStallEdgeMap().get(stallEdge);
 237
 238                         if(currentStallTagSet==null){
 239                                 currentStallTagSet=new  HashSet<StallTag>();
 240                         }
 241                         currentStallTagSet.addAll(newStallTagSet);
 242                         getStallEdgeMap().put(stallEdge,currentStallTagSet);
 243                 }
 244
 245         }
 246
 247         public Set<Long> getAllocationSiteIDSetofStallSite() {
 248
 249                 HashSet<Long> returnSet=new HashSet<Long>();
 250
 251                 Enumeration<StallSite> stallSiteEnum=stallMap.elements();
 252                 while (stallSiteEnum.hasMoreElements()) {
 253                         StallSite stallSite = (StallSite) stallSiteEnum.nextElement();
 254                         HashSet<HeapRegionNode> hrnSet=stallSite.getHRNSet();
 255                         for (Iterator iterator = hrnSet.iterator(); iterator.hasNext();) {
 256                                 HeapRegionNode hrn = (HeapRegionNode) iterator.next();
 257                                 // allocSiteIDSet.add(hrn.getGloballyUniqueIdentifier());
 258                                 returnSet.add(new Long(hrn
 259                                                 .getGloballyUniqueIntegerIdentifier()));
 260                         }
 261                 }
 262                 return returnSet;
 263
 264         }
 265
 266         public boolean equals(Object o) {
 267
 268                 if (o == null) {
 269                         return false;
 270                 }
 271
 272                 if (!(o instanceof ParentChildConflictsMap)) {
 273                         return false;
 274                 }
 275
 276                 ParentChildConflictsMap in = (ParentChildConflictsMap) o;
 277
 278                 if ( accessibleMap.equals(in.getAccessibleMap())
 279                                 && stallMap.equals(in.getStallMap()) && isAfterSESE()==in.isAfterSESE()) {
 280                         return true;
 281                 } else {
 282                         return false;
 283                 }
 284
 285         }
 286
 287         public String toString() {
 288                 return "ParentChildConflictsMap [accessibleMap=" + accessibleMap
 289                                 + ", stallMap="
 290                                 + stallMap + "]";
 291         }
 292
 293 }