changes.

diff --git a/Robust/src/Analysis/Disjoint/EffectsAnalysis.java b/Robust/src/Analysis/Disjoint/EffectsAnalysis.java
index 4d3b851ec3f17105139b105078cbd81d69099e38..52244a537e9b04b8a986852719509e5718023803 100644 (file)
--- a/Robust/src/Analysis/Disjoint/EffectsAnalysis.java
+++ b/Robust/src/Analysis/Disjoint/EffectsAnalysis.java
@@ -1,11 +1,13 @@
 package Analysis.Disjoint;
 
 import java.util.*;
+import java.util.Map.Entry;
 import java.io.*;
 
 import IR.FieldDescriptor;
 import IR.Flat.FlatCall;
 import IR.Flat.FlatMethod;
+import IR.Flat.FlatNode;
 import IR.Flat.TempDescriptor;
 import IR.Flat.FlatSESEEnterNode;
 
@@ -47,6 +49,60 @@ public class EffectsAnalysis {
   public Iterator iteratorTaintEffectPairs() {
     return taint2effects.entrySet().iterator();
   }
+  
+  public Hashtable<Taint, Set<Effect>> getSESEEffects(FlatSESEEnterNode sese){
+    
+    Hashtable<Taint, Set<Effect>> taint2Effects = new Hashtable<Taint, Set<Effect>>();
+    Iterator iter=iteratorTaintEffectPairs();
+    while (iter.hasNext()) {
+      Entry entry = (Entry) iter.next();
+      Taint taint = (Taint) entry.getKey();
+      Set<Effect> effects = (Set<Effect>) entry.getValue();
+      if (taint.getSESE().equals(sese)) {
+        Iterator<Effect> eIter = effects.iterator();
+        while (eIter.hasNext()) {
+          Effect effect = eIter.next();
+          if (taint.getSESE().equals(sese)) {
+            Set<Effect> effectSet = taint2Effects.get(taint);
+            if (effectSet == null) {
+              effectSet = new HashSet<Effect>();
+            }
+            effectSet.add(effect);
+            taint2Effects.put(taint, effectSet);
+          }
+        }
+      }
+    }
+    
+    return taint2Effects;
+    
+  }
+  
+  public Hashtable<Taint, Set<Effect>> getStallSiteEffects(FlatNode fn, TempDescriptor td){
+    
+    Hashtable<Taint, Set<Effect>> taint2Effects = new Hashtable<Taint, Set<Effect>>();
+    Iterator iter=iteratorTaintEffectPairs();
+    while(iter.hasNext()){
+      Entry entry=(Entry)iter.next();
+      Taint taint=(Taint)entry.getKey();
+      Set<Effect> effects=(Set<Effect>)entry.getValue();
+      if(taint.getStallSite().equals(fn)){
+        Iterator<Effect> eIter=effects.iterator();        
+        while (eIter.hasNext()) {
+          Effect effect = eIter.next();
+          if( taint.getStallSite().equals(fn) && taint.getVar().equals(td) ){
+            Set<Effect> effectSet=taint2Effects.get(taint);
+            if(effectSet==null){
+              effectSet=new HashSet<Effect>();
+            }
+            effectSet.add(effect);
+            taint2Effects.put(taint, effectSet);
+          }
+        }
+      }
+    }
+    return taint2Effects; 
+  }
 
 
   protected void add(Taint t, Effect e) {

diff --git a/Robust/src/Analysis/OoOJava/ConflictGraph.java b/Robust/src/Analysis/OoOJava/ConflictGraph.java
index 35017612f536eb0b7c85de155730b7b8504a2736..45b1cec6d33bdc9bd03074d3911151a521148b96 100644 (file)
--- a/Robust/src/Analysis/OoOJava/ConflictGraph.java
+++ b/Robust/src/Analysis/OoOJava/ConflictGraph.java
@@ -13,6 +13,7 @@ import java.util.Map.Entry;
 import Analysis.Disjoint.AllocSite;
 import Analysis.Disjoint.Effect;
 import Analysis.Disjoint.Taint;
+import IR.Flat.FlatNode;
 import IR.Flat.FlatSESEEnterNode;
 import IR.Flat.TempDescriptor;
 
@@ -27,6 +28,60 @@ public class ConflictGraph {
   public ConflictGraph() {
     id2cn = new Hashtable<String, ConflictNode>();
   }
+  
+  public void addLiveIn(Hashtable<Taint, Set<Effect>> taint2Effects) {
+    Iterator entryIter = taint2Effects.entrySet().iterator();
+    while (entryIter.hasNext()) {
+      Entry entry = (Entry) entryIter.next();
+      Taint taint = (Taint) entry.getKey();
+      Set<Effect> effectSet = (Set<Effect>) entry.getValue();
+      if (!effectSet.isEmpty()) {
+        Iterator<Effect> effectIter = effectSet.iterator();
+        while (effectIter.hasNext()) {
+          Effect effect = (Effect) effectIter.next();
+          addLiveInNodeEffect(taint, effect);
+        }
+      }
+    }
+  }
+
+  public void addStallSite(Hashtable<Taint, Set<Effect>> taint2Effects) {
+    Iterator entryIter = taint2Effects.entrySet().iterator();
+    while (entryIter.hasNext()) {
+      Entry entry = (Entry) entryIter.next();
+      Taint taint = (Taint) entry.getKey();
+      Set<Effect> effectSet = (Set<Effect>) entry.getValue();
+      if (!effectSet.isEmpty()) {
+        Iterator<Effect> effectIter = effectSet.iterator();
+        while (effectIter.hasNext()) {
+          Effect effect = (Effect) effectIter.next();
+          addStallSiteEffect(taint, effect);
+        }
+      }
+    }
+  }
+
+  public void addStallSiteEffect(Taint t, Effect e) {
+    FlatNode fn = t.getStallSite();
+    TempDescriptor var = t.getVar();
+    AllocSite as = t.getAllocSite();
+
+    String id = var + "_" + fn;
+    ConflictNode node = id2cn.get(id);
+    if (node == null) {
+      node = new ConflictNode(id, ConflictNode.INVAR);
+    }
+
+    if (!id2cn.containsKey(id)) {
+
+    } else {
+      node = id2cn.get(id);
+    }
+    node.addEffect(as, e);
+
+    id2cn.put(id, node);
+
+  }
 
   public void addLiveInNodeEffect(Taint t, Effect e) {
     FlatSESEEnterNode sese = t.getSESE();
@@ -100,13 +155,13 @@ public class ConflictGraph {
   private void analyzePossibleConflicts(Set<String> analyzedIDSet, ConflictNode currentNode) {
     // compare with all nodes
     // examine the case where self-edge exists
+
+    int conflictType;
     if (currentNode.isInVarNode()) {
-      // LiveInNode liveInNode = (LiveInNode) currentNode;
-      // int conflictType=calculateSelfConflictType(liveInNode);
-      // if(conflictType>0){
-      // addConflictEdge(conflictType, currentNode,
-      // currentNode);
-      // }
+      conflictType = calculateConflictType(currentNode);
+      if (conflictType > ConflictGraph.NON_WRITE_CONFLICT) {
+        addConflictEdge(conflictType, currentNode, currentNode);
+      }
     }
 
     Set<Entry<String, ConflictNode>> set = id2cn.entrySet();
@@ -129,7 +184,7 @@ public class ConflictGraph {
            * analyzedIDSet.add(currentNode.getID() + entryNodeID);
            */
         } else if (currentNode.isInVarNode() && entryNode.isInVarNode()) {
-          int conflictType = calculateConflictType(currentNode, entryNode);
+          conflictType = calculateConflictType(currentNode, entryNode);
           if (conflictType > ConflictGraph.NON_WRITE_CONFLICT) {
             addConflictEdge(conflictType, currentNode, entryNode);
           }
@@ -140,27 +195,134 @@ public class ConflictGraph {
 
   }
 
+  private int calculateConflictType(ConflictNode node) {
+
+    int conflictType = ConflictGraph.NON_WRITE_CONFLICT;
+    Hashtable<AllocSite, Set<Effect>> alloc2readEffects = node.getReadEffectSet();
+    Hashtable<AllocSite, Set<Effect>> alloc2writeEffects = node.getWriteEffectSet();
+    Hashtable<AllocSite, Set<Effect>> alloc2SUEffects = node.getStrongUpdateEffectSet();
+
+    conflictType =
+        updateConflictType(conflictType, determineConflictType(alloc2writeEffects,
+            alloc2writeEffects));
+
+    conflictType =
+        updateConflictType(conflictType, hasStrongUpdateConflicts(alloc2SUEffects,
+            alloc2readEffects, alloc2writeEffects));
+
+    return conflictType;
+  }
+
   private int calculateConflictType(ConflictNode nodeA, ConflictNode nodeB) {
 
     int conflictType = ConflictGraph.NON_WRITE_CONFLICT;
 
     Hashtable<AllocSite, Set<Effect>> alloc2readEffectsA = nodeA.getReadEffectSet();
     Hashtable<AllocSite, Set<Effect>> alloc2writeEffectsA = nodeA.getWriteEffectSet();
+    Hashtable<AllocSite, Set<Effect>> alloc2SUEffectsA = nodeA.getStrongUpdateEffectSet();
     Hashtable<AllocSite, Set<Effect>> alloc2readEffectsB = nodeB.getReadEffectSet();
     Hashtable<AllocSite, Set<Effect>> alloc2writeEffectsB = nodeB.getWriteEffectSet();
+    Hashtable<AllocSite, Set<Effect>> alloc2SUEffectsB = nodeB.getStrongUpdateEffectSet();
 
     // if node A has write effects on reading/writing regions of node B
-    conflictType = updateConflictType(conflictType, determineConflictType(alloc2writeEffectsA,
-        alloc2readEffectsB));
-    conflictType = updateConflictType(conflictType, determineConflictType(alloc2writeEffectsA,
-        alloc2writeEffectsB));
+    conflictType =
+        updateConflictType(conflictType, determineConflictType(alloc2writeEffectsA,
+            alloc2readEffectsB));
+    conflictType =
+        updateConflictType(conflictType, determineConflictType(alloc2writeEffectsA,
+            alloc2writeEffectsB));
 
     // if node B has write effects on reading regions of node A
     determineConflictType(alloc2writeEffectsB, alloc2readEffectsA);
 
+    // strong udpate effects conflict with all effects
+    // on objects that are reachable from the same heap roots
+    // if node A has SU on regions of node B
+    if (!alloc2SUEffectsA.isEmpty()) {
+      conflictType =
+          updateConflictType(conflictType, hasStrongUpdateConflicts(alloc2SUEffectsA,
+              alloc2readEffectsB, alloc2writeEffectsB));
+    }
+
+    // if node B has SU on regions of node A
+    if (!alloc2SUEffectsB.isEmpty()) {
+      conflictType =
+          updateConflictType(conflictType, hasStrongUpdateConflicts(alloc2SUEffectsB,
+              alloc2readEffectsA, alloc2writeEffectsA));
+    }
+
     return conflictType;
   }
 
+  private int hasStrongUpdateConflicts(Hashtable<AllocSite, Set<Effect>> SUEffectsTableA,
+      Hashtable<AllocSite, Set<Effect>> readTableB, Hashtable<AllocSite, Set<Effect>> writeTableB) {
+
+    int conflictType = ConflictGraph.NON_WRITE_CONFLICT;
+
+    Iterator effectItrA = SUEffectsTableA.entrySet().iterator();
+    while (effectItrA.hasNext()) {
+      Map.Entry meA = (Map.Entry) effectItrA.next();
+      AllocSite asA = (AllocSite) meA.getKey();
+      Set<Effect> strongUpdateSetA = (Set<Effect>) meA.getValue();
+
+      Iterator effectItrB = readTableB.entrySet().iterator();
+      while (effectItrB.hasNext()) {
+        Map.Entry meB = (Map.Entry) effectItrB.next();
+        AllocSite asB = (AllocSite) meA.getKey();
+        Set<Effect> esB = (Set<Effect>) meA.getValue();
+
+        for (Iterator iterator = strongUpdateSetA.iterator(); iterator.hasNext();) {
+          Effect strongUpdateA = (Effect) iterator.next();
+          for (Iterator iterator2 = esB.iterator(); iterator2.hasNext();) {
+            Effect effectB = (Effect) iterator2.next();
+
+            if (strongUpdateA.getAffectedAllocSite().equals(effectB.getAffectedAllocSite())
+                && strongUpdateA.getField().equals(effectB.getField())) {
+              // possible conflict
+              // check affected allocation site can be reached from both heap
+              // roots
+              // if(og.isReachable(asA, asB,
+              // strongUpdateA.getAffectedAllocSite()){
+              // return ConflictGraph.COARSE_GRAIN_EDGE;
+              // }
+            }
+
+          }
+        }
+      }
+
+      effectItrB = writeTableB.entrySet().iterator();
+      while (effectItrB.hasNext()) {
+        Map.Entry meB = (Map.Entry) effectItrB.next();
+        AllocSite asB = (AllocSite) meA.getKey();
+        Set<Effect> esB = (Set<Effect>) meA.getValue();
+
+        for (Iterator iterator = strongUpdateSetA.iterator(); iterator.hasNext();) {
+          Effect strongUpdateA = (Effect) iterator.next();
+          for (Iterator iterator2 = esB.iterator(); iterator2.hasNext();) {
+            Effect effectB = (Effect) iterator2.next();
+
+            if (strongUpdateA.getAffectedAllocSite().equals(effectB.getAffectedAllocSite())
+                && strongUpdateA.getField().equals(effectB.getField())) {
+              // possible conflict
+              // check affected allocation site can be reached from both heap
+              // roots
+              // if(og.isReachable(asA, asB,
+              // strongUpdateA.getAffectedAllocSite()){
+              // return ConflictGraph.COARSE_GRAIN_EDGE;
+              // }
+            }
+
+          }
+        }
+      }
+
+    }
+
+    return conflictType;
+
+  }
+
   private int determineConflictType(Hashtable<AllocSite, Set<Effect>> nodeAtable,
       Hashtable<AllocSite, Set<Effect>> nodeBtable) {
 
@@ -184,7 +346,7 @@ public class ConflictGraph {
             Effect effectB = (Effect) iterator2.next();
 
             if (effectA.getAffectedAllocSite().equals(effectB.getAffectedAllocSite())
-                && effectA.getField().equals(effectB.getField())) {             
+                && effectA.getField().equals(effectB.getField())) {
               // possible conflict
               /*
                * if(og.isReachable(asA, asB, effectA.getAffectedAllocSite())){
@@ -201,8 +363,7 @@ public class ConflictGraph {
       }
     }
 
-    return ConflictGraph.FINE_GRAIN_EDGE;
-    // return conflictType;
+    return conflictType;
   }
 
   private int updateConflictType(int current, int newType) {

diff --git a/Robust/src/Analysis/OoOJava/ConflictNode.java b/Robust/src/Analysis/OoOJava/ConflictNode.java
index c45841ad305ba92702138f1eb6786758476ae9c9..3df327e6e445550359c8181c1f21a44755c763ea 100644 (file)
--- a/Robust/src/Analysis/OoOJava/ConflictNode.java
+++ b/Robust/src/Analysis/OoOJava/ConflictNode.java
@@ -6,7 +6,6 @@ import java.util.Set;
 
 import Analysis.Disjoint.AllocSite;
 import Analysis.Disjoint.Effect;
-import Analysis.MLP.LiveInNode;
 
 public class ConflictNode {
 
@@ -85,11 +84,11 @@ public class ConflictNode {
   public Hashtable<AllocSite, Set<Effect>> getReadEffectSet() {
     return alloc2readEffectSet;
   }
-  
+
   public Hashtable<AllocSite, Set<Effect>> getWriteEffectSet() {
     return alloc2writeEffectSet;
   }
-  
+
   public Hashtable<AllocSite, Set<Effect>> getStrongUpdateEffectSet() {
     return alloc2strongUpdateEffectSet;
   }
@@ -104,8 +103,8 @@ public class ConflictNode {
   public boolean isStallSiteNode() {
     return !isInVarNode();
   }
-  
-  public Set<ConflictEdge> getEdgeSet(){
+
+  public Set<ConflictEdge> getEdgeSet() {
     return edgeSet;
   }
 
@@ -113,18 +112,6 @@ public class ConflictNode {
     edgeSet.add(edge);
   }
 
-  // public Set<Effect> getReadEffectSet() {
-  // return readEffectSet;
-  // }
-  //
-  // public Set<Effect> getWriteEffectSet() {
-  // return writeEffectSet;
-  // }
-  //
-  // public Set<Effect> getStrongUpdateEffectSet() {
-  // return strongUpdateEffectSet;
-  // }
-
   public int getType() {
     return type;
   }
@@ -132,7 +119,7 @@ public class ConflictNode {
   public String getID() {
     return id;
   }
-  
+
   public boolean equals(Object o) {
 
     if (o == null) {
@@ -152,7 +139,6 @@ public class ConflictNode {
     }
 
   }
-  
 
   public String toString() {
 

diff --git a/Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java b/Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java
index e20b95db6d8496152fc9eaab074aadd9f5f68b78..61886d1c02ca5f17eec15392d4961a40752268f9 100644 (file)
--- a/Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java
+++ b/Robust/src/Analysis/OoOJava/OoOJavaAnalysis.java
@@ -23,11 +23,13 @@ import IR.State;
 import IR.TypeUtil;
 import IR.Flat.FKind;
 import IR.Flat.FlatEdge;
+import IR.Flat.FlatFieldNode;
 import IR.Flat.FlatMethod;
 import IR.Flat.FlatNode;
 import IR.Flat.FlatOpNode;
 import IR.Flat.FlatSESEEnterNode;
 import IR.Flat.FlatSESEExitNode;
+import IR.Flat.FlatSetFieldNode;
 import IR.Flat.FlatWriteDynamicVarNode;
 import IR.Flat.TempDescriptor;
 
@@ -657,6 +659,7 @@ public class OoOJavaAnalysis {
       if (!seseStack.isEmpty()) {
 
         // Add Stall Node of current program statement
+        // disjointAnalysisTaints.getEffectsAnalysis().getEffects(t);        
 
         ConflictGraph conflictGraph = sese2conflictGraph.get(seseStack.peek());
         if (conflictGraph == null) {
@@ -682,6 +685,12 @@ public class OoOJavaAnalysis {
 
   private void conflictGraph_nodeAction(FlatNode fn, FlatSESEEnterNode currentSESE) {
 
+    EffectsAnalysis effectsAnalysis = disjointAnalysisTaints.getEffectsAnalysis();
+    ConflictGraph conflictGraph = sese2conflictGraph.get(currentSESE.getParent());
+    if (conflictGraph == null) {
+      conflictGraph = new ConflictGraph();
+    }
+    
     switch (fn.kind()) {
 
     case FKind.FlatSESEEnterNode: {
@@ -689,39 +698,48 @@ public class OoOJavaAnalysis {
       FlatSESEEnterNode fsen = (FlatSESEEnterNode) fn;
 
       if (!fsen.getIsCallerSESEplaceholder() && currentSESE.getParent() != null) {
-        Set<TempDescriptor> invar_set = fsen.getInVarSet();
-        ConflictGraph conflictGraph = sese2conflictGraph.get(currentSESE.getParent());
-        if (conflictGraph == null) {
-          conflictGraph = new ConflictGraph();
-        }
-
-        // collects effects set
-        EffectsAnalysis effectsAnalysis = disjointAnalysisTaints.getEffectsAnalysis();
-        Iterator iter=effectsAnalysis.iteratorTaintEffectPairs();
-        while(iter.hasNext()){
-          Entry entry=(Entry)iter.next();
-          Taint taint=(Taint)entry.getKey();
-          Set<Effect> effects=(Set<Effect>)entry.getValue();
-          if(taint.getSESE().equals(currentSESE)){
-            Iterator<Effect> eIter=effects.iterator();
-            while (eIter.hasNext()) {
-              Effect effect = eIter.next();
-              if (taint.getSESE().equals(currentSESE)) {
-                conflictGraph.addLiveInNodeEffect(taint, effect);
-              }
-            }
-          }
-
-        }
-
-        if (conflictGraph.id2cn.size() > 0) {
-          sese2conflictGraph.put(currentSESE.getParent(), conflictGraph);
-        }
+        // collects effects set of invar set and generates invar node
+        Hashtable<Taint, Set<Effect>> taint2Effects=effectsAnalysis.getSESEEffects(currentSESE);
+        conflictGraph.addLiveIn(taint2Effects);
       }
     }
       break;
+      
+    case FKind.FlatFieldNode:  
+    case FKind.FlatElementNode: {
+      
+      FlatFieldNode ffn = (FlatFieldNode) fn;
+      TempDescriptor rhs = ffn.getSrc();
+      
+      // add stall site      
+      Hashtable<Taint, Set<Effect>> taint2Effects=effectsAnalysis.getStallSiteEffects(fn, rhs);
+      conflictGraph.addStallSite(taint2Effects);
+      
+    }    
+      break;
+      
+    case FKind.FlatSetFieldNode: 
+    case FKind.FlatSetElementNode: {
+      
+      FlatSetFieldNode fsfn = (FlatSetFieldNode) fn;
+      TempDescriptor lhs = fsfn.getDst();
+      TempDescriptor rhs = fsfn.getSrc();
+      
+      // collects effects of stall site and generates stall site node
+      Hashtable<Taint, Set<Effect>> taint2Effects=effectsAnalysis.getStallSiteEffects(fn, rhs);
+      conflictGraph.addStallSite(taint2Effects);
+      
+      taint2Effects=effectsAnalysis.getStallSiteEffects(fn, lhs);
+      conflictGraph.addStallSite(taint2Effects);
+      
+    }    
+      break;
     }
 
+    if (conflictGraph.id2cn.size() > 0) {
+      sese2conflictGraph.put(currentSESE.getParent(), conflictGraph);
+    }
+    
   }
   
   private void calculateConflicts() {