Global sweep added

diff --git a/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java b/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java
index e474ad63c446e92f2d874506d8cf0a0a85e315aa..5436e856fcfb8730395b278ab7dcd84a38bf65fc 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java
@@ -10,6 +10,7 @@ public class HeapRegionNode extends OwnershipNode {
 
   protected boolean isSingleObject;
   protected boolean isFlagged;
+  protected boolean isParameter;
   protected boolean isNewSummary;
 
   protected HashSet<ReferenceEdge> referencers;
@@ -26,6 +27,7 @@ public class HeapRegionNode extends OwnershipNode {
   public HeapRegionNode(Integer id,
                         boolean isSingleObject,
                         boolean isFlagged,
+                       boolean isParameter,
                         boolean isNewSummary,
                         AllocationSite allocSite,
                         ReachabilitySet alpha,
@@ -33,6 +35,7 @@ public class HeapRegionNode extends OwnershipNode {
     this.id = id;
     this.isSingleObject = isSingleObject;
     this.isFlagged      = isFlagged;
+    this.isParameter    = isParameter;
     this.isNewSummary   = isNewSummary;
     this.allocSite      = allocSite;
     this.alpha          = alpha;
@@ -46,6 +49,7 @@ public class HeapRegionNode extends OwnershipNode {
     return new HeapRegionNode(id,
                               isSingleObject,
                               isFlagged,
+                             isParameter,
                               isNewSummary,
                               allocSite,
                               alpha,
@@ -80,6 +84,7 @@ public class HeapRegionNode extends OwnershipNode {
 
     assert isSingleObject == hrn.isSingleObject();
     assert isFlagged      == hrn.isFlagged();
+    assert isParameter    == hrn.isParameter();
     assert isNewSummary   == hrn.isNewSummary();
     assert description.equals(hrn.getDescription() );
 
@@ -99,6 +104,10 @@ public class HeapRegionNode extends OwnershipNode {
     return isFlagged;
   }
 
+  public boolean isParameter() {
+    return isParameter;
+  }
+
   public boolean isNewSummary() {
     return isNewSummary;
   }

diff --git a/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java b/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
index 126f288615cf607b560daa1f28afd958fbdec132..95c7c4f0a247ad8c8d4c54ec6e47d5f51fbad8ed 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
@@ -100,6 +100,7 @@ public class OwnershipGraph {
     HeapRegionNode hrn = new HeapRegionNode(id,
                                             isSingleObject,
                                             isFlagged,
+                                           isParameter,
                                             isNewSummary,
                                             allocSite,
                                             alpha,
@@ -412,12 +413,39 @@ public class OwnershipGraph {
     HashSet<HeapRegionNode> nodesWithNewAlpha = new HashSet<HeapRegionNode>();
     HashSet<ReferenceEdge>  edgesWithNewBeta  = new HashSet<ReferenceEdge>();
 
+
+    // first look for possible strong updates and remove those edges
     boolean strongUpdate = false;
 
     Iterator<ReferenceEdge> itrXhrn = lnX.iteratorToReferencees();
     while( itrXhrn.hasNext() ) {
       ReferenceEdge edgeX = itrXhrn.next();
-      HeapRegionNode hrnX  = edgeX.getDst();
+      HeapRegionNode hrnX = edgeX.getDst();
+
+      Iterator<ReferenceEdge> itrYhrn = lnY.iteratorToReferencees();
+      while( itrYhrn.hasNext() ) {
+       ReferenceEdge edgeY = itrYhrn.next();
+       HeapRegionNode hrnY = edgeY.getDst();
+
+       // we can do a strong update here if one of two cases holds     
+       if( f != null &&
+           hrnX.isSingleObject() &&
+           (   (hrnX.getNumReferencers() == 1)                           ||
+               ( lnX.getNumReferencees() == 1)
+           )
+         ) {
+         strongUpdate = true;
+         clearReferenceEdgesFrom( hrnX, f, false );
+       }
+      }
+    }
+
+    
+    // then do all token propagation
+    itrXhrn = lnX.iteratorToReferencees();
+    while( itrXhrn.hasNext() ) {
+      ReferenceEdge edgeX = itrXhrn.next();
+      HeapRegionNode hrnX = edgeX.getDst();
       ReachabilitySet betaX = edgeX.getBeta();
 
       ReachabilitySet R = hrnX.getAlpha().intersection(edgeX.getBeta() );
@@ -425,8 +453,8 @@ public class OwnershipGraph {
       Iterator<ReferenceEdge> itrYhrn = lnY.iteratorToReferencees();
       while( itrYhrn.hasNext() ) {
        ReferenceEdge edgeY = itrYhrn.next();
-       HeapRegionNode hrnY  = edgeY.getDst();
-       ReachabilitySet O     = edgeY.getBeta();
+       HeapRegionNode hrnY = edgeY.getDst();
+       ReachabilitySet O = edgeY.getBeta();
 
 
        // propagate tokens over nodes starting from hrnSrc, and it will
@@ -454,50 +482,49 @@ public class OwnershipGraph {
        propagateTokensOverEdges(todoEdges,
                                 edgePlannedChanges,
                                 edgesWithNewBeta);
+      }
+    }
 
-       // if edgeY's beta was updated, use that to calculate beta for new edge
-       // otherwise the edgeY didn't change and it is the source for the calc
-       ReachabilitySet sourceBetaForNewEdge;
-       //if( edgesWithNewBeta.contains( edgeY ) ) {
-       if( !edgeY.getBetaNew().equals( new ReachabilitySet().makeCanonical() ) ) {
-         sourceBetaForNewEdge = edgeY.getBetaNew();
-       } else {
-         sourceBetaForNewEdge = edgeY.getBeta();
-       }
 
-       ReachabilitySet sourceAlphaForPrune;
-       if( !hrnX.getAlphaNew().equals( new ReachabilitySet().makeCanonical() ) ) {
-         sourceAlphaForPrune = hrnX.getAlphaNew();
-       } else {
-         sourceAlphaForPrune = hrnX.getAlpha();
-       }       
+    // apply the updates to reachability
+    Iterator<HeapRegionNode> nodeItr = nodesWithNewAlpha.iterator();
+    while( nodeItr.hasNext() ) {
+      nodeItr.next().applyAlphaNew();
+    }
+
+    Iterator<ReferenceEdge> edgeItr = edgesWithNewBeta.iterator();
+    while( edgeItr.hasNext() ) {
+      edgeItr.next().applyBetaNew();
+    }
+
+
+    // then go back through and add the new edges
+    itrXhrn = lnX.iteratorToReferencees();
+    while( itrXhrn.hasNext() ) {
+      ReferenceEdge edgeX = itrXhrn.next();
+      HeapRegionNode hrnX = edgeX.getDst();
+
+      Iterator<ReferenceEdge> itrYhrn = lnY.iteratorToReferencees();
+      while( itrYhrn.hasNext() ) {
+       ReferenceEdge edgeY = itrYhrn.next();
+       HeapRegionNode hrnY = edgeY.getDst();
 
        // prepare the new reference edge hrnX.f -> hrnY
        ReferenceEdge edgeNew = new ReferenceEdge(hrnX,
                                                  hrnY,
                                                  f,
                                                  false,
-                                                 sourceBetaForNewEdge.pruneBy( sourceAlphaForPrune )
+                                                 edgeY.getBeta().pruneBy( hrnX.getAlpha() )
                                                  );
 
-       // we can do a strong update here if one of two cases holds     
-       if( f != null &&
-           (   (hrnX.getNumReferencers() == 1)                           ||
-               ( lnX.getNumReferencees() == 1 && hrnX.isSingleObject() )
-           )
-         ) {
-         strongUpdate = true;
-         clearReferenceEdgesFrom( hrnX, f, false );
-       }
-
        // look to see if an edge with same field exists
        // and merge with it, otherwise just add the edge
        ReferenceEdge edgeExisting = hrnX.getReferenceTo( hrnY, f );
-         
+       
        if( edgeExisting != null ) {
-         edgeExisting.setBetaNew(
-                                 edgeExisting.getBetaNew().union( edgeNew.getBeta() )
-                                 );
+         edgeExisting.setBeta(
+                              edgeExisting.getBeta().union( edgeNew.getBeta() )
+                             );
          // a new edge here cannot be reflexive, so existing will
          // always be also not reflexive anymore
          edgeExisting.setIsInitialParamReflexive( false );
@@ -507,24 +534,11 @@ public class OwnershipGraph {
       }
     }
 
-    Iterator<HeapRegionNode> nodeItr = nodesWithNewAlpha.iterator();
-    while( nodeItr.hasNext() ) {
-      nodeItr.next().applyAlphaNew();
-    }
 
-    Iterator<ReferenceEdge> edgeItr = edgesWithNewBeta.iterator();
-    while( edgeItr.hasNext() ) {
-      edgeItr.next().applyBetaNew();
-    }
-
-    // if it was a strong update, make sure to improve
+    // if there was a strong update, make sure to improve
     // reachability with a global sweep
     if( strongUpdate ) {      
-      //try {
-      //writeGraph( "testBefore", true, true, true, false, false );
-       globalSweep();
-       //writeGraph( "testPost", true, true, true, false, false );
-       //} catch( Exception e ) {}
+      globalSweep();
     }  
   }
 
@@ -1514,8 +1528,7 @@ public class OwnershipGraph {
       }
     }
 
-    // last thing in the entire method call is to do a global sweep
-    // and try to clean up a little bit
+    // improve reachability as much as possible
     globalSweep();
   }
 
@@ -1828,8 +1841,8 @@ public class OwnershipGraph {
     Hashtable<HeapRegionNode, HashSet<TokenTupleSet> > workSet = 
       new Hashtable<HeapRegionNode, HashSet<TokenTupleSet> >();
 
-    // first initialize every alphaNew for a flagged region to
-    // a set with just that token
+    // first initialize every alphaNew for a flagged region
+    // (or parameter region) to a set with just that token
     Set hrns = id2hrn.entrySet();
     Iterator itrHrns = hrns.iterator();
     while( itrHrns.hasNext() ) {
@@ -1840,8 +1853,6 @@ public class OwnershipGraph {
       // assert that this node and incoming edges have clean alphaNew
       // and betaNew sets, respectively
       ReachabilitySet rsEmpty = new ReachabilitySet().makeCanonical();
-      //System.out.println( "hrn="+hrn );
-      //System.out.println( "alphaNew="+hrn.getAlphaNew() );
       assert rsEmpty.equals( hrn.getAlphaNew() );
 
       Iterator<ReferenceEdge> itrRes = hrn.iteratorToReferencers();
@@ -1859,7 +1870,7 @@ public class OwnershipGraph {
       TokenTupleSet ttsStar  = new TokenTupleSet( ttStar ).makeCanonical();
       TokenTupleSet ttsEmpty = new TokenTupleSet(        ).makeCanonical();
 
-      if( hrn.isFlagged() ) {
+      if( hrn.isFlagged() || hrn.isParameter() ) {
        HashSet<TokenTupleSet> subWorkSet = new HashSet<TokenTupleSet>();
        subWorkSet.add( tts     );
        subWorkSet.add( ttsPlus );
@@ -1893,13 +1904,13 @@ public class OwnershipGraph {
       Iterator<ReferenceEdge> itrRes = hrn.iteratorToReferencees();
       while( itrRes.hasNext() ) {
        ReferenceEdge edge = itrRes.next();
+
        if( edge.getBeta().containsSuperSet( tts ) ) {
          HeapRegionNode dst = edge.getDst();
 
          // make a set of possible contributions this token
          // might have on the alpha set here
          HashSet<TokenTupleSet> ttsNewSet = new HashSet<TokenTupleSet>();
-         //ttsNewSet.add( tts );
 
          Iterator<TokenTupleSet> itrDstAlphaNew = dst.getAlphaNew().iterator();
          while( itrDstAlphaNew.hasNext() ) {

diff --git a/Robust/src/Benchmarks/Ownership/BankApp.txt b/Robust/src/Benchmarks/Ownership/BankApp.txt
index b1ec1c2ba20926b4224c040518da2e13fcfb60fc..283458e8874e8c0a9b3259994a38bbb5e963bb67 100644 (file)
--- a/Robust/src/Benchmarks/Ownership/BankApp.txt
+++ b/Robust/src/Benchmarks/Ownership/BankApp.txt
@@ -1,9 +1,9 @@
 Conducting ownership analysis with allocation depth = 1
 ---------AcceptConnection(ServerSocket ss)--------
-Task AcceptConnection(ServerSocket ss) contains no aliases between flagged objects.
+No aliases between flagged objects in Task AcceptConnection(ServerSocket ss).
 
 ---------Startup(StartupObject s)--------
-Task Startup(StartupObject s) contains no aliases between flagged objects.
+No aliases between flagged objects in Task Startup(StartupObject s).
 
 ---------ProcessRequest(BankAppSocket bas, BankDatabase Bank)--------
-Task ProcessRequest(BankAppSocket bas, BankDatabase Bank) contains no aliases between flagged objects.
+No aliases between flagged objects in Task ProcessRequest(BankAppSocket bas, BankDatabase Bank).

diff --git a/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java b/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
index 3787b57f232686162a46c6658d9a5b309bd65aec..fbd452857fa339dadd64ff653ca29f998eb47fc5 100644 (file)
--- a/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
+++ b/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
@@ -206,7 +206,7 @@ task Startup( StartupObject s{ initialstate } ) {
   taskexit( s{ !initialstate } );
 }
 
-/*
+
 
 task NewObjectA( Foo a{ f }, Foo b{ f } ) {
 
@@ -327,7 +327,7 @@ task SummaryNodeTokens( Foo p0{ f } ) {
 
     taskexit( p0{ !f } );
 }
-*/
+
 
 task strongUpdates( Foo p0{ f } ) {
 
@@ -363,7 +363,7 @@ task strongUpdates( Foo p0{ f } ) {
     taskexit( p0{ !f } );
 }
 
-/*
+
 
 task ObjectChainByMethodCalls( Foo a{ f } ) {
 
@@ -619,7 +619,7 @@ task methodTest06_( Foo p0{ f }, Foo p1{ f } ) {
     a1after.x = new Foo();
   }
 
-  //Foo.m6_( a0after, a1after );
+  Foo.m6_( a0after, a1after );
 
 
   taskexit( p0{ !f }, p1{ !f } );
@@ -656,7 +656,7 @@ task methodTest07_( Foo p0{ f }, Foo p1{ f } ) {
     a1after.x = new Foo();
   }
 
-  //Foo.m7_( a0after, a1after );
+  Foo.m7_( a0after, a1after );
 
 
   taskexit( p0{ !f }, p1{ !f } );
@@ -693,14 +693,13 @@ task methodTest08_( Foo p0{ f }, Foo p1{ f } ) {
     a1after.x = new Foo();
   }
 
-  //Foo.m8_( a0after, a1after );
+  Foo.m8_( a0after, a1after );
 
 
   taskexit( p0{ !f }, p1{ !f } );
 }
-*/
 
-/*
+
 task methodTest09_( Foo p0{ f }, Foo p1{ f } ) {
 
   Foo a0before = new Foo();
@@ -736,4 +735,4 @@ task methodTest09_( Foo p0{ f }, Foo p1{ f } ) {
 
   taskexit( p0{ !f }, p1{ !f } );
 }
-*/
+