HeapRegionNode and ReferenceEdge both have had the equals() and hashCode()

methods updated to exclude transient attributes like reachability information.
If these objects are put into work sets and those attributes are changed they
have become different objects, according to the hash set.  So equals() was changed
and other methods are used for determining equality in other situations, like
asking whether heap region nodes in different graphs are equivalent.

Also, a few other minor changes.

diff --git a/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java b/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java
index 3c14a6cc9bc2a9925dc4e753907825b0391d5b04..e9fb24940ec7ed9143d4a2f62bc1a2b0128b5d59 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java
@@ -58,6 +58,11 @@ public class HeapRegionNode extends OwnershipNode {
     }
 
 
+    public boolean equalsIncludingAlpha( HeapRegionNode hrn ) {
+       return equals( hrn ) && alpha.equals( hrn.alpha );
+    }
+
+
     public boolean equals( Object o ) {
        if( o == null ) {
            return false;
@@ -78,20 +83,11 @@ public class HeapRegionNode extends OwnershipNode {
        assert isNewSummary   == hrn.isNewSummary();
        assert description.equals( hrn.getDescription() ); 
 
-       return alpha.equals( hrn.getAlpha() );
-
-       /*
-       return id.equals( hrn.getID() )            &&
-           isSingleObject == hrn.isSingleObject() &&
-           isFlagged      == hrn.isFlagged()      &&
-           isNewSummary   == hrn.isNewSummary()   &&
-           alpha.equals( hrn.getAlpha() )         &&
-           description.equals( hrn.getDescription() );
-       */
+       return true;
     }
 
     public int hashCode() {
-       return id.intValue()*17 + alpha.hashCode();
+       return id.intValue()*17;
     }
 
 

diff --git a/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java b/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
index d4eb8fe20a2bdd3610bd5a8a98fe20a4604ea0a5..3c68b4ae42f84f0d9c331867e5f2254e929d9ab0 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/OwnershipGraph.java
@@ -150,6 +150,7 @@ public class OwnershipGraph {
 
            if( removeAll || edge.getFieldDesc() == fieldDesc ) {
                HeapRegionNode referencee = edge.getDst();
+
                removeReferenceEdge( referencer,
                                     referencee,
                                     edge.getFieldDesc() );
@@ -179,25 +180,24 @@ public class OwnershipGraph {
     }
     
 
-    /*
-    protected void propagateTokensOverNodes( HeapRegionNode                   nPrime,
-                                            ChangeTupleSet                   c0,
-                                            HashSet<HeapRegionNode>          nodesWithNewAlpha,
-                                            HashSet<ReferenceEdgeProperties> edgesWithNewBeta ) {      
+    protected void propagateTokensOverNodes( HeapRegionNode          nPrime,
+                                            ChangeTupleSet          c0,
+                                            HashSet<HeapRegionNode> nodesWithNewAlpha,
+                                            HashSet<ReferenceEdge>  edgesWithNewBeta ) {       
 
        HashSet<HeapRegionNode> todoNodes
            = new HashSet<HeapRegionNode>();
        todoNodes.add( nPrime );
 
-       HashSet<ReferenceEdgeProperties> todoEdges 
-           = new HashSet<ReferenceEdgeProperties>();
+       HashSet<ReferenceEdge> todoEdges 
+           = new HashSet<ReferenceEdge>();
        
        Hashtable<HeapRegionNode, ChangeTupleSet> nodePlannedChanges 
            = new Hashtable<HeapRegionNode, ChangeTupleSet>();
        nodePlannedChanges.put( nPrime, c0 );
 
-       Hashtable<ReferenceEdgeProperties, ChangeTupleSet> edgePlannedChanges 
-           = new Hashtable<ReferenceEdgeProperties, ChangeTupleSet>();
+       Hashtable<ReferenceEdge, ChangeTupleSet> edgePlannedChanges 
+           = new Hashtable<ReferenceEdge, ChangeTupleSet>();
        
 
        while( !todoNodes.isEmpty() ) {
@@ -215,33 +215,29 @@ public class OwnershipGraph {
                }
            }
 
-           Iterator referItr = n.iteratorToReferencers();
+           Iterator<ReferenceEdge> referItr = n.iteratorToReferencers();
            while( referItr.hasNext() ) {
-               OwnershipNode           on  = (OwnershipNode) referItr.next();
-               ReferenceEdgeProperties rep = on.getReferenceTo( n );
-               todoEdges.add( rep );
+               ReferenceEdge edge = referItr.next();
+               todoEdges.add( edge );
 
-               if( !edgePlannedChanges.containsKey( rep ) ) {
-                   edgePlannedChanges.put( rep, new ChangeTupleSet().makeCanonical() );
+               if( !edgePlannedChanges.containsKey( edge ) ) {
+                   edgePlannedChanges.put( edge, new ChangeTupleSet().makeCanonical() );
                }
 
-               edgePlannedChanges.put( rep, edgePlannedChanges.get( rep ).union( C ) );
+               edgePlannedChanges.put( edge, edgePlannedChanges.get( edge ).union( C ) );
            }
 
-           HeapRegionNode          m = null;
-           ReferenceEdgeProperties f = null;
-           Iterator refeeItr = n.setIteratorToReferencedRegions();
+           Iterator<ReferenceEdge> refeeItr = n.iteratorToReferencees();
            while( refeeItr.hasNext() ) {
-               Map.Entry me = (Map.Entry)               refeeItr.next();
-               m            = (HeapRegionNode)          me.getKey();
-               f            = (ReferenceEdgeProperties) me.getValue();
+               ReferenceEdge  edgeF = refeeItr.next();
+               HeapRegionNode m     = edgeF.getDst();
 
                ChangeTupleSet changesToPass = new ChangeTupleSet().makeCanonical();
 
-               Iterator itrCprime = C.iterator();
+               Iterator<ChangeTuple> itrCprime = C.iterator();
                while( itrCprime.hasNext() ) {
-                   ChangeTuple c = (ChangeTuple) itrCprime.next();
-                   if( f.getBeta().contains( c.getSetToMatch() ) ) {
+                   ChangeTuple c = itrCprime.next();
+                   if( edgeF.getBeta().contains( c.getSetToMatch() ) ) {
                        changesToPass = changesToPass.union( c );
                    }
                }
@@ -269,60 +265,58 @@ public class OwnershipGraph {
 
 
     protected void propagateTokensOverEdges( 
-        HashSet<ReferenceEdgeProperties>                   todoEdges,
-        Hashtable<ReferenceEdgeProperties, ChangeTupleSet> edgePlannedChanges,
-        HashSet<HeapRegionNode>                            nodesWithNewAlpha,
-        HashSet<ReferenceEdgeProperties>                   edgesWithNewBeta ) {
+        HashSet<ReferenceEdge>                   todoEdges,
+        Hashtable<ReferenceEdge, ChangeTupleSet> edgePlannedChanges,
+        HashSet<HeapRegionNode>                  nodesWithNewAlpha,
+        HashSet<ReferenceEdge>                   edgesWithNewBeta ) {
        
 
        while( !todoEdges.isEmpty() ) {
-           ReferenceEdgeProperties e = todoEdges.iterator().next();
-           todoEdges.remove( e );
+           ReferenceEdge edgeE = todoEdges.iterator().next();
+           todoEdges.remove( edgeE );
 
-           if( !edgePlannedChanges.containsKey( e ) ) {
-               edgePlannedChanges.put( e, new ChangeTupleSet().makeCanonical() );
+           if( !edgePlannedChanges.containsKey( edgeE ) ) {
+               edgePlannedChanges.put( edgeE, new ChangeTupleSet().makeCanonical() );
            }
            
-           ChangeTupleSet C = edgePlannedChanges.get( e );
+           ChangeTupleSet C = edgePlannedChanges.get( edgeE );
 
            ChangeTupleSet changesToPass = new ChangeTupleSet().makeCanonical();
 
-           Iterator itrC = C.iterator();
+           Iterator<ChangeTuple> itrC = C.iterator();
            while( itrC.hasNext() ) {
-               ChangeTuple c = (ChangeTuple) itrC.next();
-               if( e.getBeta().contains( c.getSetToMatch() ) ) {
-                   ReachabilitySet withChange = e.getBeta().union( c.getSetToAdd() );
-                   e.setBetaNew( e.getBetaNew().union( withChange ) );
-                   edgesWithNewBeta.add( e );
+               ChangeTuple c = itrC.next();
+               if( edgeE.getBeta().contains( c.getSetToMatch() ) ) {
+                   ReachabilitySet withChange = edgeE.getBeta().union( c.getSetToAdd() );
+                   edgeE.setBetaNew( edgeE.getBetaNew().union( withChange ) );
+                   edgesWithNewBeta.add( edgeE );
                    changesToPass = changesToPass.union( c );
                }
            }
 
-           OwnershipNode onSrc = e.getSrc();
+           OwnershipNode onSrc = edgeE.getSrc();
 
            if( !changesToPass.isEmpty() && onSrc instanceof HeapRegionNode ) {         
                HeapRegionNode n = (HeapRegionNode) onSrc;
-               Iterator referItr = n.iteratorToReferencers();
 
+               Iterator<ReferenceEdge> referItr = n.iteratorToReferencers();
                while( referItr.hasNext() ) {
-                   OwnershipNode onRef = (OwnershipNode) referItr.next();
-                   ReferenceEdgeProperties f = onRef.getReferenceTo( n );
+                   ReferenceEdge edgeF = referItr.next();
                    
-                   if( !edgePlannedChanges.containsKey( f ) ) {
-                       edgePlannedChanges.put( f, new ChangeTupleSet().makeCanonical() );
+                   if( !edgePlannedChanges.containsKey( edgeF ) ) {
+                       edgePlannedChanges.put( edgeF, new ChangeTupleSet().makeCanonical() );
                    }
                  
-                   ChangeTupleSet currentChanges = edgePlannedChanges.get( f );
+                   ChangeTupleSet currentChanges = edgePlannedChanges.get( edgeF );
                
                    if( !changesToPass.isSubset( currentChanges ) ) {
-                       todoEdges.add( f );
-                       edgePlannedChanges.put( f, currentChanges.union( changesToPass ) );
+                       todoEdges.add( edgeF );
+                       edgePlannedChanges.put( edgeF, currentChanges.union( changesToPass ) );
                    }
                }
            }       
        }       
     }
-    */
 
 
     ////////////////////////////////////////////////////
@@ -405,10 +399,8 @@ public class OwnershipGraph {
        LabelNode lnX = getLabelNodeFromTemp( x );
        LabelNode lnY = getLabelNodeFromTemp( y );
 
-       /*
-       HashSet<HeapRegionNode>          nodesWithNewAlpha = new HashSet<HeapRegionNode>();
-       HashSet<ReferenceEdgeProperties> edgesWithNewBeta  = new HashSet<ReferenceEdgeProperties>();
-       */
+       HashSet<HeapRegionNode> nodesWithNewAlpha = new HashSet<HeapRegionNode>();
+       HashSet<ReferenceEdge>  edgesWithNewBeta  = new HashSet<ReferenceEdge>();
 
        Iterator<ReferenceEdge> itrXhrn = lnX.iteratorToReferencees();
        while( itrXhrn.hasNext() ) {
@@ -416,80 +408,61 @@ public class OwnershipGraph {
            HeapRegionNode  hrnX  = edgeX.getDst();
            ReachabilitySet betaX = edgeX.getBeta();
 
-           //ReachabilitySet R = hrn.getAlpha().intersection( rep.getBeta() );
+           ReachabilitySet R = hrnX.getAlpha().intersection( edgeX.getBeta() );
 
            Iterator<ReferenceEdge> itrYhrn = lnY.iteratorToReferencees();
            while( itrYhrn.hasNext() ) {
                ReferenceEdge   edgeY = itrYhrn.next();
-               HeapRegionNode  hrnY  = edgeY.getDst();
-               ReachabilitySet betaY = edgeY.getBeta();
-               
-               //ReachabilitySet O = repSrc.getBeta();
+               HeapRegionNode  hrnY  = edgeY.getDst();         
+               ReachabilitySet O     = edgeY.getBeta();
 
-               /*
                // propagate tokens over nodes starting from hrnSrc, and it will
                // take care of propagating back up edges from any touched nodes
                ChangeTupleSet Cy = O.unionUpArityToChangeSet( R );
-               propagateTokensOverNodes( hrnSrc, Cy, nodesWithNewAlpha, edgesWithNewBeta );
+               propagateTokensOverNodes( hrnY, Cy, nodesWithNewAlpha, edgesWithNewBeta );
 
 
                // then propagate back just up the edges from hrn
                ChangeTupleSet Cx = R.unionUpArityToChangeSet( O );
 
-               HashSet<ReferenceEdgeProperties> todoEdges = 
-                   new HashSet<ReferenceEdgeProperties>();
+               HashSet<ReferenceEdge> todoEdges = new HashSet<ReferenceEdge>();
 
-               Hashtable<ReferenceEdgeProperties, ChangeTupleSet> edgePlannedChanges =
-                   new Hashtable<ReferenceEdgeProperties, ChangeTupleSet>();
+               Hashtable<ReferenceEdge, ChangeTupleSet> edgePlannedChanges =
+                   new Hashtable<ReferenceEdge, ChangeTupleSet>();
 
-               Iterator referItr = hrn.iteratorToReferencers();
+               Iterator<ReferenceEdge> referItr = hrnX.iteratorToReferencers();
                while( referItr.hasNext() ) {
-                   OwnershipNode onRef = (OwnershipNode) referItr.next();
-
-                   System.out.println( "    "+onRef+" is upstream" );
-
-                   ReferenceEdgeProperties repUpstream = onRef.getReferenceTo( hrn );
-
-                   todoEdges.add( repUpstream );
-                   edgePlannedChanges.put( repUpstream, Cx );
+                   ReferenceEdge edgeUpstream = referItr.next();
+                   todoEdges.add( edgeUpstream );
+                   edgePlannedChanges.put( edgeUpstream, Cx );
                }
 
-               System.out.println( "plans "+edgePlannedChanges );
-
                propagateTokensOverEdges( todoEdges, 
                                          edgePlannedChanges,
                                          nodesWithNewAlpha,
                                          edgesWithNewBeta );
 
-               System.out.println( "  Onew = "+repSrc.getBetaNew() );
-               */
-
                // finally, create the actual reference edge hrnX.f -> hrnY
                ReferenceEdge edgeNew = new ReferenceEdge( hrnX,
                                                           hrnY,
                                                           f,
                                                           false,
-                                                          null );
-
-                                                          /*
-                                                          repSrc.getBetaNew().pruneBy( hrn.getAlpha()
-                                                          */
+                                                          edgeY.getBetaNew().pruneBy( hrnX.getAlpha() )
+                                                        );
 
                addReferenceEdge( hrnX, hrnY, edgeNew );
            }
        }       
 
-       /*
-       Iterator nodeItr = nodesWithNewAlpha.iterator();
+       Iterator<HeapRegionNode> nodeItr = nodesWithNewAlpha.iterator();
        while( nodeItr.hasNext() ) {
-           ((HeapRegionNode) nodeItr.next()).applyAlphaNew();
+           nodeItr.next().applyAlphaNew();
        }
 
-       Iterator edgeItr = edgesWithNewBeta.iterator();
+       Iterator<ReferenceEdge> edgeItr = edgesWithNewBeta.iterator();
        while( edgeItr.hasNext() ) {
-           ((ReferenceEdgeProperties) edgeItr.next()).applyBetaNew();
-       }       
-       */
+           edgeItr.next().applyBetaNew();
+       }
     }
 
 
@@ -621,39 +594,32 @@ public class OwnershipGraph {
        clearReferenceEdgesFrom( hrn0, null, true );
        clearReferenceEdgesTo  ( hrn0, null, true );
        
-       /*
+       
        // now tokens in reachability sets need to "age" also
-       ReferenceEdgeProperties repToAge = null;
        Iterator itrAllLabelNodes = td2ln.entrySet().iterator();
        while( itrAllLabelNodes.hasNext() ) {
            Map.Entry me = (Map.Entry) itrAllLabelNodes.next();
            LabelNode ln = (LabelNode) me.getValue();
 
-           Iterator itrEdges = ln.setIteratorToReferencedRegions();
+           Iterator<ReferenceEdge> itrEdges = ln.iteratorToReferencees();
            while( itrEdges.hasNext() ) {
-               Map.Entry meE = (Map.Entry)               itrEdges.next();
-               repToAge      = (ReferenceEdgeProperties) meE.getValue();
-
-               ageTokens( as, repToAge );
+               ageTokens( as, itrEdges.next() );
            }
        }
-       HeapRegionNode hrnToAge = null;
+
        Iterator itrAllHRNodes = id2hrn.entrySet().iterator();
        while( itrAllHRNodes.hasNext() ) {
-           Map.Entry me = (Map.Entry)               itrAllHRNodes.next();
-           hrnToAge     = (HeapRegionNode)          me.getValue();
+           Map.Entry      me       = (Map.Entry)      itrAllHRNodes.next();
+           HeapRegionNode hrnToAge = (HeapRegionNode) me.getValue();
 
            ageTokens( as, hrnToAge );
 
-           Iterator itrEdges = hrnToAge.setIteratorToReferencedRegions();
+           Iterator<ReferenceEdge> itrEdges = hrnToAge.iteratorToReferencees();
            while( itrEdges.hasNext() ) {
-               Map.Entry meE = (Map.Entry)               itrEdges.next();
-               repToAge      = (ReferenceEdgeProperties) meE.getValue();
-
-               ageTokens( as, repToAge );
+               ageTokens( as, itrEdges.next() );
            }
        }
-       */
+
 
        // after tokens have been aged, reset newest node's reachability
        hrn0.setAlpha( new ReachabilitySet( 
@@ -832,23 +798,22 @@ public class OwnershipGraph {
     }
 
 
-    /*
-    protected void ageTokens( AllocationSite as, ReferenceEdgeProperties rep ) {
-       rep.setBeta( rep.getBeta().ageTokens( as ) );
+    protected void ageTokens( AllocationSite as, ReferenceEdge edge ) {
+       edge.setBeta( edge.getBeta().ageTokens( as ) );
     }
 
     protected void ageTokens( AllocationSite as, HeapRegionNode hrn ) {
        hrn.setAlpha( hrn.getAlpha().ageTokens( as ) );
     }
 
-    protected void majorAgeTokens( AllocationSite as, ReferenceEdgeProperties rep ) {
-       //rep.setBeta( rep.getBeta().majorAgeTokens( as ) );
+    protected void majorAgeTokens( AllocationSite as, ReferenceEdge edge ) {
+       //edge.setBeta( edge.getBeta().majorAgeTokens( as ) );
     }
 
     protected void majorAgeTokens( AllocationSite as, HeapRegionNode hrn ) {
        //hrn.setAlpha( hrn.getAlpha().majorAgeTokens( as ) );
     }
-    */
+
     
     // some notes:
     // the heap regions that are specially allocated as multiple-object
@@ -1156,10 +1121,11 @@ public class OwnershipGraph {
 
                    ReferenceEdge  edgeB     = heapRegionsItrB.next();
                    HeapRegionNode hrnChildB = edgeB.getDst();
+                   Integer        idChildB  = hrnChildB.getID();
 
                    // don't use the ReferenceEdge.equals() here because
                    // we're talking about existence between graphs
-                   if( hrnChildB.equals( idChildA ) &&
+                   if( idChildB.equals( idChildA ) &&
                        edgeB.getFieldDesc() == edgeA.getFieldDesc() ) {
                        edgeToMerge = edgeB;
                    }
@@ -1347,7 +1313,7 @@ public class OwnershipGraph {
            }
 
            HeapRegionNode hrnB = ogB.id2hrn.get( idA );            
-           if( !hrnA.equals( hrnB ) ) {
+           if( !hrnA.equalsIncludingAlpha( hrnB ) ) {
                return false;
            }       
        }
@@ -1480,8 +1446,9 @@ public class OwnershipGraph {
            while( itrB.hasNext() ) {
                ReferenceEdge  edgeB     = itrB.next();
                HeapRegionNode hrnChildB = edgeB.getDst();
+               Integer        idChildB  = hrnChildB.getID();
 
-               if( idChildA.equals( hrnChildB.getID() ) &&
+               if( idChildA.equals( idChildB ) &&
                    edgeA.getFieldDesc() == edgeB.getFieldDesc() ) {
 
                    // there is an edge in the right place with the right field,

diff --git a/Robust/src/Analysis/OwnershipAnalysis/OwnershipNode.java b/Robust/src/Analysis/OwnershipAnalysis/OwnershipNode.java
index aebfcdfa6f65c66666b746c0374a532f791dd909..f005fff10fca4b9f6701e11909bfcae0c56df2e1 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/OwnershipNode.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/OwnershipNode.java
@@ -51,27 +51,4 @@ public abstract class OwnershipNode {
 
        return null;
     }
-
-    /*
-    public HashSet<ReferenceEdge> getAllReferencesTo( HeapRegionNode  hrn ) {
-       assert hrn != null;
-
-       HashSet<ReferenceEdge> s = new HashSet<ReferenceEdge>();
-
-       Iterator<ReferenceEdge> itrEdge = referencees.iterator();
-       while( itrEdge.hasNext() ) {
-           ReferenceEdge edge = itrEdge.next();
-           if( edge.getDst().equals( hrn ) ) {
-               s.add( edge );
-           }
-       }
-
-       return s;
-    }
-    */
-
-    /*
-    abstract public boolean equals( Object o );
-    abstract public int hashCode();
-    */
 }
\ No newline at end of file

diff --git a/Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java b/Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java
index 85d3e34e475ec4df348015e59df66223a70f6cdf..81e557b0512a926c5759c5b3a250f16f36300db9 100644 (file)
--- a/Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java
+++ b/Robust/src/Analysis/OwnershipAnalysis/ReferenceEdge.java
@@ -66,12 +66,6 @@ public class ReferenceEdge {
            return false;
        }
 
-       /*
-       if( !src.equals( edge.src ) ||
-           !dst.equals( edge.dst )   ) {
-           return false;
-       }
-       */
        // Equality of edges is only valid within a graph, so
        // compare src and dst by reference
        if( !(src == edge.src) ||
@@ -79,23 +73,7 @@ public class ReferenceEdge {
            return false;
        }
 
-       // think of this as being used to put edges in a hashset
-       // as a work pool.  If the field src, dst and field match
-       // then it should otherwise be the same edge
-
-       assert isInitialParamReflexive == edge.isInitialParamReflexive;
-       assert beta.equals( edge.beta );
-
        return true;
-
-       /*
-       // field descriptors maintain the invariant that they are reference comparable
-       return fieldDesc               == re.fieldDesc               &&
-              isInitialParamReflexive == re.isInitialParamReflexive &&
-              src.equals ( re.src  )                                &&
-              dst.equals ( re.dst  )                                &&
-              beta.equals( re.beta );
-       */
     }
 
     public int hashCode() {
@@ -105,16 +83,9 @@ public class ReferenceEdge {
            hash += fieldDesc.getType().hashCode();
        }
 
-       if( isInitialParamReflexive ) {
-           hash += 1;
-       }
-
        hash += src.hashCode()*11;
-
        hash += dst.hashCode();
 
-       hash += beta.hashCode()*2;
-
        return hash;
     }
 
@@ -180,12 +151,6 @@ public class ReferenceEdge {
        betaNew = new ReachabilitySet().makeCanonical();
     }
 
-
-    /*
-    public String getBetaString() {
-       return beta.toStringEscapeNewline();
-    }
-    */
     
     public String toGraphEdgeString() {
        String edgeLabel = "";

diff --git a/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java b/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
index 151cef1776f6e7736c657fc0cfadb428caaca666..7cfb7de9c32b81d6f131f3f0a2b81527c2ca92f1 100644 (file)
--- a/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
+++ b/Robust/src/Tests/OwnershipAnalysisTest/test01/test01.java
@@ -46,7 +46,7 @@ public class Foo {
     public void ruinSomeFoos( Foo a, Foo b ) {
        a.x = b.x;
     }
-
+    */
 
     static public void test( Foo p0, Foo p1 ) {
        Foo f0 = new Foo();
@@ -58,7 +58,6 @@ public class Foo {
        p1.x = f1;
        p1.x = f2;
     }
-    */
 }
 
 
@@ -68,7 +67,7 @@ public class Foo {
 // a heap region that is multi-object, flagged, not summary
 task Startup( StartupObject s{ initialstate } ) {
     
-    /*
+
     while( false ) {
        Foo a = new Foo();
        a.x   = new Foo();
@@ -112,7 +111,7 @@ task Startup( StartupObject s{ initialstate } ) {
        c.x = b;
        b = c;
     }
-    */
+
 
     taskexit( s{ !initialstate } );
 }
@@ -136,7 +135,7 @@ task basics( Foo p0{ f }, Foo p1{ f } ) {
     taskexit( p0{ !f }, p1{ !f } );
 }
 
-/*
+
 task methodTest( Foo p0{ f } ) {
 
     Foo up0 = new Foo();
@@ -169,7 +168,7 @@ task methodTest( Foo p0{ f } ) {
 
     taskexit( p0{ !f } );
 }
-*/
+
 
 
 

diff --git a/Robust/src/Tests/OwnershipAnalysisTest/testGraphs/Main.java b/Robust/src/Tests/OwnershipAnalysisTest/testGraphs/Main.java
index d64e43aa1439999b107d3dc7d42437112e7385a2..016f3e62155e47bfc491c0df03281fc832e5d371 100644 (file)
--- a/Robust/src/Tests/OwnershipAnalysisTest/testGraphs/Main.java
+++ b/Robust/src/Tests/OwnershipAnalysisTest/testGraphs/Main.java
@@ -186,25 +186,25 @@ public class Main {
        OwnershipGraph g0     = new OwnershipGraph( allocationDepth );
        TempDescriptor g0tdp1 = new TempDescriptor( "p1" );
        TempDescriptor g0tdx  = new TempDescriptor( "x" );
-       g0.assignTempToParameterAllocation( true, g0tdp1, new Integer( 0 ) );
-       g0.assignTempXToTempY             ( g0tdx, g0tdp1 );
+       g0.assignParameterAllocationToTemp( true, g0tdp1, new Integer( 0 ) );
+       g0.assignTempYToTempX             ( g0tdp1, g0tdx );
 
        OwnershipGraph g1     = new OwnershipGraph( allocationDepth );
        TempDescriptor g1tdp2 = new TempDescriptor( "p2" );
        TempDescriptor g1tdy  = new TempDescriptor( "y" );
        TempDescriptor g1tdz  = new TempDescriptor( "z" );
-       g1.assignTempToParameterAllocation( true, g1tdp2, new Integer( 0 ) );
-       g1.assignTempXToTempY             ( g1tdy, g1tdp2 );
-       g1.assignTempXToTempYFieldF       ( g1tdz, g1tdp2, null );
+       g1.assignParameterAllocationToTemp( true, g1tdp2, new Integer( 0 ) );
+       g1.assignTempYToTempX             ( g1tdp2, g1tdy );
+       g1.assignTempYFieldFToTempX       ( g1tdp2, null, g1tdz );
 
        OwnershipGraph g2     = new OwnershipGraph( allocationDepth );
        TempDescriptor g2tdp3 = new TempDescriptor( "p3" );
        TempDescriptor g2tdp4 = new TempDescriptor( "p4" );
        TempDescriptor g2tdw  = new TempDescriptor( "w" );
-       g2.assignTempToParameterAllocation( true, g2tdp3, new Integer( 0 ) );
-       g2.assignTempToParameterAllocation( true, g2tdp4, new Integer( 1 ) );
-       g2.assignTempXToTempY             ( g2tdw,  g2tdp4 );
-       g2.assignTempXFieldFToTempY       ( g2tdp3, null, g2tdw );
+       g2.assignParameterAllocationToTemp( true, g2tdp3, new Integer( 0 ) );
+       g2.assignParameterAllocationToTemp( true, g2tdp4, new Integer( 1 ) );
+       g2.assignTempYToTempX             ( g2tdp4, g2tdw );
+       g2.assignTempYToTempXFieldF       ( g2tdw, g2tdp3, null );
 
        OwnershipGraph g3 = new OwnershipGraph( allocationDepth );
        g3.merge( g0 );
@@ -219,13 +219,15 @@ public class Main {
        OwnershipGraph g5     = new OwnershipGraph( allocationDepth );
        TempDescriptor g5tdp1 = new TempDescriptor( "p1" );
        TempDescriptor g5tdy  = new TempDescriptor( "y" );
-       g5.assignTempToParameterAllocation( true, g5tdp1, new Integer( 0 ) );
-       g5.assignTempXToTempY             ( g5tdy, g5tdp1 );
+       g5.assignParameterAllocationToTemp( true, g5tdp1, new Integer( 0 ) );
+       g5.assignTempYToTempX             ( g5tdp1, g5tdy );
 
+       /*
        try {
            g3.writeGraph( "g3", true, false, false, false );
            g4.writeGraph( "g4", true, false, false, false );
        } catch( IOException e ) {}
+       */
 
        test( "g0 equals to g1?", false, g0.equals( g1 ) );
        test( "g1 equals to g0?", false, g1.equals( g0 ) );