Updates to check in.

diff --git a/Repair/RepairCompiler/MCC/IR/AbstractInterferes.java b/Repair/RepairCompiler/MCC/IR/AbstractInterferes.java
index df039333a395a34d8e909c3d8ef0bf045932f333..6b09ac49bf5edb419d05eb204e9ed6173e7aee4c 100755 (executable)
--- a/Repair/RepairCompiler/MCC/IR/AbstractInterferes.java
+++ b/Repair/RepairCompiler/MCC/IR/AbstractInterferes.java
@@ -134,9 +134,24 @@ class AbstractInterferes {
             if (!leftside.equals(mapping,e2))
                 return false;
         }
+
+
         /* Prune precondition using any ar's in the same conjunction */
         adjustcondition(precondition, ar);
         Conjunction conj=findConjunction(repair_c.getDNFConstraint(),ar.getPredicate());
+
+        /* We don't interfere with the same constraint, if there
+            aren't any shared state problems between different
+            bindings (which we've already checked for), and its a
+            different conjunction.  Because we wouldn't have repair it
+            if it wasn't already broken.  Doesn't appear to be needed,
+            the cycle algorithm will just eliminate one of the nodes.
+
+            if (repair_c==interfere_c) {
+            if (conj!=findConjunction(interfere_c.getDNFConstraint(),interfere_pred))
+            return true;
+            }*/
+
         for(int i=0;i<conj.size();i++) {
             DNFPredicate dp=conj.get(i);
             Set s=(Set)termination.predtoabstractmap.get(dp);

diff --git a/Repair/RepairCompiler/MCC/IR/Termination.java b/Repair/RepairCompiler/MCC/IR/Termination.java
index ff9a293a7874e36a63ad491afbc1ccfcb7d2205b..917b44f63f793dd0081f5b21db7e5201ff4198c9 100755 (executable)
--- a/Repair/RepairCompiler/MCC/IR/Termination.java
+++ b/Repair/RepairCompiler/MCC/IR/Termination.java
@@ -67,20 +67,26 @@ public class Termination {
        generateconjunctionnodes();
        constraintdependence=new ConstraintDependence(state,this);
 
+        debugmsg("Generating scope nodes");
        generatescopenodes();
+        debugmsg("Generating repair nodes");
        generaterepairnodes();
+        debugmsg("Generating data structure nodes");
        generatedatastructureupdatenodes();
+        debugmsg("Generating compensation nodes");
        generatecompensationnodes();
-
+        debugmsg("Generating abstract edges");
        generateabstractedges();
+        debugmsg("Generating scope edges");
        generatescopeedges();
+        debugmsg("Generating update edges");
        generateupdateedges();
 
 
        HashSet superset=new HashSet();
        superset.addAll(conjunctions);
        HashSet closureset=new HashSet();
-
+        debugmsg("Computing closure");
        GraphNode.computeclosure(superset,closureset);
        try {
            GraphNode.DOTVisitor.visit(new FileOutputStream("graph.dot"),superset);
@@ -287,11 +293,11 @@ public class Termination {
                 } else {
                     for(int i=0;i<conj.size();i++) {
                         DNFPredicate dp=conj.get(i);
-                        if (getConstraint(gn)!=null&&
-                            abstractinterferes.interferemodifies(ar,getConstraint(gn),dp,cons))
-                            continue;
 
-                        if (abstractinterferes.interfereswithpredicate(ar,dp)) {
+                        if (!abstractinterferes.interfereswithpredicate(ar,dp))
+                            continue;
+                        if (getConstraint(gn)==null||
+                            !abstractinterferes.interferemodifies(ar,getConstraint(gn),dp,cons)) {
                             GraphNode.Edge e=new GraphNode.Edge("interferes",gn2);
                             gn.addEdge(e);
                             break;