From ffb52167b226337c265430e5e131a8b175a2667d Mon Sep 17 00:00:00 2001 From: jjenista Date: Fri, 15 Aug 2008 18:47:49 +0000 Subject: [PATCH] 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. --- .../OwnershipAnalysis/HeapRegionNode.java | 18 +- .../OwnershipAnalysis/OwnershipGraph.java | 199 ++++++++---------- .../OwnershipAnalysis/OwnershipNode.java | 23 -- .../OwnershipAnalysis/ReferenceEdge.java | 35 --- .../OwnershipAnalysisTest/test01/test01.java | 11 +- .../testGraphs/Main.java | 24 ++- 6 files changed, 108 insertions(+), 202 deletions(-) diff --git a/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java b/Robust/src/Analysis/OwnershipAnalysis/HeapRegionNode.java index 3c14a6cc..e9fb2494 100644 --- 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 d4eb8fe2..3c68b4ae 100644 --- 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 nodesWithNewAlpha, - HashSet edgesWithNewBeta ) { + protected void propagateTokensOverNodes( HeapRegionNode nPrime, + ChangeTupleSet c0, + HashSet nodesWithNewAlpha, + HashSet edgesWithNewBeta ) { HashSet todoNodes = new HashSet(); todoNodes.add( nPrime ); - HashSet todoEdges - = new HashSet(); + HashSet todoEdges + = new HashSet(); Hashtable nodePlannedChanges = new Hashtable(); nodePlannedChanges.put( nPrime, c0 ); - Hashtable edgePlannedChanges - = new Hashtable(); + Hashtable edgePlannedChanges + = new Hashtable(); while( !todoNodes.isEmpty() ) { @@ -215,33 +215,29 @@ public class OwnershipGraph { } } - Iterator referItr = n.iteratorToReferencers(); + Iterator 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 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 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 todoEdges, - Hashtable edgePlannedChanges, - HashSet nodesWithNewAlpha, - HashSet edgesWithNewBeta ) { + HashSet todoEdges, + Hashtable edgePlannedChanges, + HashSet nodesWithNewAlpha, + HashSet 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 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 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 nodesWithNewAlpha = new HashSet(); - HashSet edgesWithNewBeta = new HashSet(); - */ + HashSet nodesWithNewAlpha = new HashSet(); + HashSet edgesWithNewBeta = new HashSet(); Iterator 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 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 todoEdges = - new HashSet(); + HashSet todoEdges = new HashSet(); - Hashtable edgePlannedChanges = - new Hashtable(); + Hashtable edgePlannedChanges = + new Hashtable(); - Iterator referItr = hrn.iteratorToReferencers(); + Iterator 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 nodeItr = nodesWithNewAlpha.iterator(); while( nodeItr.hasNext() ) { - ((HeapRegionNode) nodeItr.next()).applyAlphaNew(); + nodeItr.next().applyAlphaNew(); } - Iterator edgeItr = edgesWithNewBeta.iterator(); + Iterator 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 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 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 aebfcdfa..f005fff1 100644 --- 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 getAllReferencesTo( HeapRegionNode hrn ) { - assert hrn != null; - - HashSet s = new HashSet(); - - Iterator 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 85d3e34e..81e557b0 100644 --- 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 151cef17..7cfb7de9 100644 --- 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 d64e43aa..016f3e62 100644 --- 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 ) ); -- 2.34.1