From 2d6e4651b1b99f9641ba9fda0ccc2974ef2195f4 Mon Sep 17 00:00:00 2001
From: bdemsky <bdemsky>
Date: Tue, 9 Nov 2004 16:51:28 +0000
Subject: [PATCH] Updates to check in.

---
 .../MCC/IR/AbstractInterferes.java             | 15 +++++++++++++++
 Repair/RepairCompiler/MCC/IR/Termination.java  | 18 ++++++++++++------
 2 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/Repair/RepairCompiler/MCC/IR/AbstractInterferes.java b/Repair/RepairCompiler/MCC/IR/AbstractInterferes.java
index df03933..6b09ac4 100755
--- 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 ff9a293..917b44f 100755
--- 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;
-- 
2.34.1