Robust/src/Analysis/OoOJava/SESELock.java

   1 package Analysis.OoOJava;
   2
   3 import java.util.HashMap;
   4 import java.util.HashSet;
   5 import java.util.Iterator;
   6 import java.util.Set;
   7
   8 public class SESELock {
   9
  10   private HashSet<ConflictNode> conflictNodeSet;
  11   private HashSet<ConflictEdge> conflictEdgeSet;
  12   private HashMap<ConflictNode, Integer> nodeTypeMap;
  13   private int id;
  14
  15   public SESELock() {
  16     conflictNodeSet = new HashSet<ConflictNode>();
  17     conflictEdgeSet = new HashSet<ConflictEdge>();
  18     nodeTypeMap = new HashMap<ConflictNode, Integer>();
  19   }
  20
  21   public void addConflictNode(ConflictNode node, int type) {
  22     conflictNodeSet.add(node);
  23     setNodeType(node, type);
  24   }
  25
  26   public void setNodeType(ConflictNode node, int type) {
  27     nodeTypeMap.put(node, new Integer(type));
  28   }
  29
  30   public int getNodeType(ConflictNode node) {
  31     return nodeTypeMap.get(node).intValue();
  32   }
  33
  34   public void addConflictEdge(ConflictEdge e) {
  35     conflictEdgeSet.add(e);
  36   }
  37
  38   public boolean containsConflictEdge(ConflictEdge e) {
  39     return conflictEdgeSet.contains(e);
  40   }
  41
  42   public HashSet<ConflictNode> getConflictNodeSet() {
  43     return conflictNodeSet;
  44   }
  45
  46   public boolean isWriteNode(ConflictNode node) {
  47     if (node.getWriteEffectSet().isEmpty()) {
  48       return false;
  49     } else {
  50       return true;
  51     }
  52   }
  53
  54   public boolean hasSelfCoarseEdge(ConflictNode node) {
  55
  56     Set<ConflictEdge> set = node.getEdgeSet();
  57     for (Iterator iterator = set.iterator(); iterator.hasNext(); ) {
  58       ConflictEdge conflictEdge = (ConflictEdge) iterator.next();
  59
  60       if (conflictEdge.isCoarseEdge() && conflictEdge.getVertexU() == conflictEdge.getVertexV()) {
  61         return true;
  62       }
  63     }
  64     return false;
  65   }
  66
  67   public boolean hasSelfEdge(ConflictNode node) {
  68
  69     Set<ConflictEdge> set = node.getEdgeSet();
  70     for (Iterator iterator = set.iterator(); iterator.hasNext(); ) {
  71       ConflictEdge conflictEdge = (ConflictEdge) iterator.next();
  72
  73       if ((!conflictEdge.isCoarseEdge()) && conflictEdge.getVertexU() == conflictEdge.getVertexV()) {
  74         return true;
  75       }
  76     }
  77     return false;
  78   }
  79
  80   public boolean hasCoarseEdgeWithParentCoarse(ConflictNode node) {
  81
  82     Set<ConflictEdge> set = node.getEdgeSet();
  83     for (Iterator iterator = set.iterator(); iterator.hasNext(); ) {
  84       ConflictEdge conflictEdge = (ConflictEdge) iterator.next();
  85
  86       ConflictNode cNode;
  87       if (conflictEdge.getVertexU() == node) {
  88         cNode = conflictEdge.getVertexV();
  89       } else {
  90         cNode = conflictEdge.getVertexU();
  91       }
  92       Integer cNodeTypeIn = nodeTypeMap.get(cNode);
  93       if (cNodeTypeIn != null && cNodeTypeIn.intValue() == ConflictNode.PARENT_COARSE) {
  94         return true;
  95       }
  96     }
  97     return false;
  98   }
  99
 100   public ConflictNode getNewNodeConnectedWithGroup(ConflictEdge newEdge) {
 101
 102     // check whether or not the new node has a fine-grained edges to all
 103     // current nodes.
 104
 105     ConflictNode newNode;
 106     if (conflictNodeSet.contains(newEdge.getVertexU())) {
 107       newNode = newEdge.getVertexV();
 108     } else if (conflictNodeSet.contains(newEdge.getVertexV())) {
 109       newNode = newEdge.getVertexU();
 110     } else {
 111       return null;
 112     }
 113
 114
 115     int count = 0;
 116     Set<ConflictEdge> edgeSet = newNode.getEdgeSet();
 117     for (Iterator iterator = edgeSet.iterator(); iterator.hasNext(); ) {
 118       ConflictEdge conflictEdge = (ConflictEdge) iterator.next();
 119       if (!conflictEdge.getVertexU().equals(newNode)
 120           && conflictNodeSet.contains(conflictEdge.getVertexU())) {
 121         count++;
 122       } else if (!conflictEdge.getVertexV().equals(newNode)
 123                  && conflictNodeSet.contains(conflictEdge.getVertexV())) {
 124         count++;
 125       }
 126     }
 127
 128     if(conflictNodeSet.contains(newNode)) {
 129       count++;
 130     }
 131
 132     if(isWriteNode(newNode)) {
 133       if (count == conflictNodeSet.size()) {
 134         // connected to all current nodes in group
 135         return newNode;
 136       }
 137     } else {
 138       // it is read node
 139       int writeNodeCount=0;
 140       for (Iterator iterator = conflictNodeSet.iterator(); iterator.hasNext(); ) {
 141         ConflictNode node = (ConflictNode) iterator.next();
 142         if(isWriteNode(node)) {
 143           writeNodeCount++;
 144         }
 145       }
 146       if (count == writeNodeCount) {
 147         // connected to all current write nodes in group
 148         return newNode;
 149       }
 150     }
 151
 152     return null;
 153
 154   }
 155
 156   public void addEdge(ConflictEdge edge) {
 157     conflictNodeSet.add(edge.getVertexU());
 158     conflictNodeSet.add(edge.getVertexV());
 159   }
 160
 161   public int getID() {
 162     return id;
 163   }
 164
 165   public void setID(int id) {
 166     this.id = id;
 167   }
 168
 169   public boolean containsConflictNode(ConflictNode node) {
 170
 171     return conflictNodeSet.contains(node);
 172
 173   }
 174
 175   public boolean testEdge(ConflictEdge newEdge) {
 176
 177     if (!conflictNodeSet.contains(newEdge.getVertexU())
 178         && !conflictNodeSet.contains(newEdge.getVertexV())) {
 179       return false;
 180     }
 181
 182     ConflictNode nodeToAdd = conflictNodeSet.contains(newEdge.getVertexU())?newEdge.getVertexV()
 183                              :newEdge.getVertexU();
 184
 185     HashSet<ConflictNode> nodeSet = new HashSet<ConflictNode>(conflictNodeSet);
 186
 187     for (Iterator edgeIter = nodeToAdd.getEdgeSet().iterator(); edgeIter.hasNext(); ) {
 188       ConflictEdge edge = (ConflictEdge) edgeIter.next();
 189       if (nodeSet.contains(edge.getVertexU())) {
 190         nodeSet.remove(edge.getVertexU());
 191       } else if (nodeSet.contains(edge.getVertexV())) {
 192         nodeSet.remove(edge.getVertexV());
 193       }
 194     }
 195
 196     return nodeSet.isEmpty();
 197
 198   }
 199
 200   public String toString() {
 201     String rtr = "";
 202
 203     for (Iterator<ConflictNode> iterator = conflictNodeSet.iterator(); iterator.hasNext(); ) {
 204       ConflictNode node = (ConflictNode) iterator.next();
 205       rtr += " " + node + "::" + getNodeType(node);
 206     }
 207
 208     return rtr;
 209   }
 210
 211 }