import Analysis.CallGraph.*;
import IR.*;
import IR.Flat.*;
+import IR.Tree.Modifiers;
import java.util.*;
import java.io.*;
public class OwnershipAnalysis {
+
///////////////////////////////////////////
//
// Public interface to discover possible
// aliases in the program under analysis
//
///////////////////////////////////////////
- /*
- public HashSet<AllocationSite>
- getFlaggedAllocationSitesReachableFromTask( TaskDescriptor td ) {
- return getFlaggedAllocationSitesReachableFromTaskPRIVATE( td );
- }
+ public HashSet<AllocationSite>
+ getFlaggedAllocationSitesReachableFromTask(TaskDescriptor td) {
+ return getFlaggedAllocationSitesReachableFromTaskPRIVATE(td);
+ }
- public AllocationSite getAllocationSiteFromFlatNew( FlatNew fn ) {
- return getAllocationSiteFromFlatNewPRIVATE( fn );
- }
+ public AllocationSite getAllocationSiteFromFlatNew(FlatNew fn) {
+ return getAllocationSiteFromFlatNewPRIVATE(fn);
+ }
- public boolean createsPotentialAliases( Descriptor taskOrMethod,
- int paramIndex1,
- int paramIndex2 ) {
+ public boolean createsPotentialAliases(Descriptor taskOrMethod,
+ int paramIndex1,
+ int paramIndex2) {
- OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get( taskOrMethod );
- assert( og != null );
+ OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get(taskOrMethod);
+ assert(og != null);
+ return og.hasPotentialAlias(paramIndex1, paramIndex2);
+ }
- return createsPotentialAliases( og,
- getHeapRegionIDset( og, paramIndex1 ),
- getHeapRegionIDset( og, paramIndex2 ) );
- }
+ public boolean createsPotentialAliases(Descriptor taskOrMethod,
+ int paramIndex,
+ AllocationSite alloc) {
- public boolean createsPotentialAliases( Descriptor taskOrMethod,
- int paramIndex,
- AllocationSite alloc ) {
+ OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get(taskOrMethod);
+ assert(og != null);
+ return og.hasPotentialAlias(paramIndex, alloc);
+ }
- OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get( taskOrMethod );
- assert( og != null );
+ public boolean createsPotentialAliases(Descriptor taskOrMethod,
+ AllocationSite alloc,
+ int paramIndex) {
- return createsPotentialAliases( og,
- getHeapRegionIDset( og, paramIndex ),
- getHeapRegionIDset( alloc ) );
- }
+ OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get(taskOrMethod);
+ assert(og != null);
+ return og.hasPotentialAlias(paramIndex, alloc);
+ }
- public boolean createsPotentialAliases( Descriptor taskOrMethod,
- AllocationSite alloc,
- int paramIndex ) {
+ public boolean createsPotentialAliases(Descriptor taskOrMethod,
+ AllocationSite alloc1,
+ AllocationSite alloc2) {
- OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get( taskOrMethod );
- assert( og != null );
+ OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get(taskOrMethod);
+ assert(og != null);
+ return og.hasPotentialAlias(alloc1, alloc2);
+ }
- return createsPotentialAliases( og,
- getHeapRegionIDset( og, paramIndex ),
- getHeapRegionIDset( alloc ) );
- }
+ // use the methods given above to check every possible alias
+ // between task parameters and flagged allocation sites reachable
+ // from the task
+ public void writeAllAliases(String outputFile) throws java.io.IOException {
- public boolean createsPotentialAliases( Descriptor taskOrMethod,
- AllocationSite alloc1,
- AllocationSite alloc2 ) {
+ BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile) );
- OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get( taskOrMethod );
- assert( og != null );
+ // look through every task for potential aliases
+ Iterator taskItr = state.getTaskSymbolTable().getDescriptorsIterator();
+ while( taskItr.hasNext() ) {
+ TaskDescriptor td = (TaskDescriptor) taskItr.next();
- return createsPotentialAliases( og,
- getHeapRegionIDset( alloc1 ),
- getHeapRegionIDset( alloc2 ) );
- }
+ bw.write("\n---------"+td+"--------\n");
- public boolean createsPotentialAliases( Descriptor taskOrMethod,
- AllocationSite alloc,
- HashSet<AllocationSite> allocSet ) {
+ HashSet<AllocationSite> allocSites = getFlaggedAllocationSitesReachableFromTask(td);
- OwnershipGraph og = mapDescriptorToCompleteOwnershipGraph.get( taskOrMethod );
- assert( og != null );
+ // for each task parameter, check for aliases with
+ // other task parameters and every allocation site
+ // reachable from this task
+ boolean foundSomeAlias = false;
- return createsPotentialAliases( og,
- getHeapRegionIDset( alloc ),
- getHeapRegionIDset( allocSet ) );
- }
- */
+ FlatMethod fm = state.getMethodFlat(td);
+ for( int i = 0; i < fm.numParameters(); ++i ) {
- // use the methods given above to check every possible alias
- // between task parameters and flagged allocation sites reachable
- // from the task
- public void writeAllAliases(String outputFile) throws java.io.IOException {
+ // for the ith parameter check for aliases to all
+ // higher numbered parameters
+ for( int j = i + 1; j < fm.numParameters(); ++j ) {
+ if( createsPotentialAliases(td, i, j) ) {
+ foundSomeAlias = true;
+ bw.write("Potential alias between parameters "+i+" and "+j+".\n");
+ }
+ }
- BufferedWriter bw = new BufferedWriter(new FileWriter(outputFile) );
- /*
- // look through every task for potential aliases
- Iterator taskItr = state.getTaskSymbolTable().getDescriptorsIterator();
- while( taskItr.hasNext() ) {
- TaskDescriptor td = (TaskDescriptor) taskItr.next();
-
- HashSet<AllocationSite> allocSites = getFlaggedAllocationSitesReachableFromTask( td );
-
- // for each task parameter, check for aliases with
- // other task parameters and every allocation site
- // reachable from this task
- FlatMethod fm = state.getMethodFlat( td );
- for( int i = 0; i < fm.numParameters(); ++i ) {
-
- // for the ith parameter check for aliases to all
- // higher numbered parameters
- for( int j = i + 1; j < fm.numParameters(); ++j ) {
- if( createsPotentialAliases( td, i, j ) ) {
- bw.write( "Task "+td+" potentially aliases parameters "+i+" and "+j+".\n" );
- }
- }
-
- // for the ith parameter, check for aliases against
- // the set of allocation sites reachable from this
- // task context
- Iterator allocItr = allocSites.iterator();
- while( allocItr.hasNext() ) {
- AllocationSite as = (AllocationSite) allocItr.next();
- if( createsPotentialAliases( td, i, as ) ) {
- bw.write( "Task "+td+" potentially aliases parameter "+i+" and "+as+".\n" );
- }
- }
- }
-
- // for each allocation site check for aliases with
- // other allocation sites in the context of execution
- // of this task
- Iterator allocItr = allocSites.iterator();
- while( allocItr.hasNext() ) {
- AllocationSite as = (AllocationSite) allocItr.next();
- if( createsPotentialAliases( td, as, allocSites ) ) {
- bw.write( "Task "+td+" potentially aliases "+as+" and the rest of the set.\n" );
- }
- }
- }
-
- bw.close();
- */
+ // for the ith parameter, check for aliases against
+ // the set of allocation sites reachable from this
+ // task context
+ Iterator allocItr = allocSites.iterator();
+ while( allocItr.hasNext() ) {
+ AllocationSite as = (AllocationSite) allocItr.next();
+ if( createsPotentialAliases(td, i, as) ) {
+ foundSomeAlias = true;
+ bw.write("Potential alias between parameter "+i+" and "+as+".\n");
+ }
+ }
+ }
+
+ // for each allocation site check for aliases with
+ // other allocation sites in the context of execution
+ // of this task
+ HashSet<AllocationSite> outerChecked = new HashSet<AllocationSite>();
+ Iterator allocItr1 = allocSites.iterator();
+ while( allocItr1.hasNext() ) {
+ AllocationSite as1 = (AllocationSite) allocItr1.next();
+
+ Iterator allocItr2 = allocSites.iterator();
+ while( allocItr2.hasNext() ) {
+ AllocationSite as2 = (AllocationSite) allocItr2.next();
+
+ if( !outerChecked.contains(as2) &&
+ createsPotentialAliases(td, as1, as2) ) {
+ bw.write("Potential alias between "+as1+" and "+as2+".\n");
+ }
+ }
+
+ outerChecked.add(as1);
+ }
+
+ if( !foundSomeAlias ) {
+ bw.write("Task "+td+" contains no aliases between flagged objects.\n");
+ }
+ }
+
+ bw.close();
}
///////////////////////////////////////////
// ownership graph with an object in another
// graph that logically represents the same
// heap region
- static private int uniqueIDcount = 0;
+ // start at 10 and incerement to leave some
+ // reserved IDs for special purposes
+ static private int uniqueIDcount = 10;
// Use these data structures to track progress of
// processing all methods in the program, and by methods
// TaskDescriptor and MethodDescriptor are combined
// together, with a common parent class Descriptor
- private HashSet <Descriptor> descriptorsToVisit;
private Hashtable<Descriptor, OwnershipGraph> mapDescriptorToCompleteOwnershipGraph;
private Hashtable<FlatNew, AllocationSite> mapFlatNewToAllocationSite;
private Hashtable<Descriptor, HashSet<AllocationSite> > mapDescriptorToAllocationSiteSet;
private Hashtable<FlatNode, OwnershipGraph> mapFlatNodeToOwnershipGraph;
private HashSet <FlatReturnNode> returnNodesToCombineForCompleteOwnershipGraph;
+ // descriptorsToAnalyze identifies the set of tasks and methods
+ // that are reachable from the program tasks, this set is initialized
+ // and then remains static
+ private HashSet<Descriptor> descriptorsToAnalyze;
+
+ // descriptorsToVisit is initialized to descriptorsToAnalyze and is
+ // reduced by visiting a descriptor during analysis. When dependents
+ // must be scheduled, only those contained in descriptorsToAnalyze
+ // should be re-added to this set
+ private HashSet<Descriptor> descriptorsToVisit;
+
+ // a special field descriptor for all array elements
+ private static FieldDescriptor fdElement = new FieldDescriptor(new Modifiers(Modifiers.PUBLIC),
+ new TypeDescriptor("Array[]"),
+ "elements",
+ null,
+ false);
+
// this analysis generates an ownership graph for every task
// in the program
this.callGraph = callGraph;
this.allocationDepth = allocationDepth;
- // temporary for debugging
- this.allocationDepth = 1;
- descriptorsToVisit = new HashSet<Descriptor>();
+ descriptorsToAnalyze = new HashSet<Descriptor>();
mapDescriptorToCompleteOwnershipGraph =
new Hashtable<Descriptor, OwnershipGraph>();
mapDescriptorToAllocationSiteSet =
new Hashtable<Descriptor, HashSet<AllocationSite> >();
- // use this set to prevent infinite recursion when
- // traversing the call graph
- HashSet<Descriptor> calleesScheduled = new HashSet<Descriptor>();
-
// initialize methods to visit as the set of all tasks in the
// program and then any method that could be called starting
Iterator taskItr = state.getTaskSymbolTable().getDescriptorsIterator();
while( taskItr.hasNext() ) {
Descriptor d = (Descriptor) taskItr.next();
- descriptorsToVisit.add(d);
-
- // recursively find all callees from this task
- scheduleAllCallees(calleesScheduled, d);
+ scheduleAllCallees(d);
}
// before beginning analysis, initialize every scheduled method
// with an ownership graph that has populated parameter index tables
// by analyzing the first node which is always a FlatMethod node
- Iterator<Descriptor> dItr = calleesScheduled.iterator();
+ Iterator<Descriptor> dItr = descriptorsToAnalyze.iterator();
while( dItr.hasNext() ) {
Descriptor d = dItr.next();
OwnershipGraph og = new OwnershipGraph(allocationDepth);
fm = state.getMethodFlat( (TaskDescriptor) d);
}
+ System.out.println("Previsiting " + d);
+
analyzeFlatNode(d, fm, null, og);
mapDescriptorToCompleteOwnershipGraph.put(d, og);
}
+ System.out.println("");
+
// as mentioned above, analyze methods one-by-one, possibly revisiting
// a method if the methods that it calls are updated
analyzeMethods();
+
+ writeAllAliases("identifiedAliases.txt");
}
// called from the constructor to help initialize the set
// of methods that needs to be analyzed by ownership analysis
- private void scheduleAllCallees(HashSet<Descriptor> calleesScheduled,
- Descriptor d) {
- if( calleesScheduled.contains(d) ) {
+ private void scheduleAllCallees(Descriptor d) {
+ if( descriptorsToAnalyze.contains(d) ) {
return;
}
- calleesScheduled.add(d);
+ descriptorsToAnalyze.add(d);
- Set callees = callGraph.getCalleeSet(d);
- if( callees == null ) {
- return;
+ // start with all method calls to further schedule
+ Set moreMethodsToCheck = moreMethodsToCheck = callGraph.getMethodCalls(d);
+
+ if( d instanceof MethodDescriptor ) {
+ // see if this method has virtual dispatch
+ Set virtualMethods = callGraph.getMethods( (MethodDescriptor)d);
+ moreMethodsToCheck.addAll(virtualMethods);
}
- Iterator methItr = callees.iterator();
+ // keep following any further methods identified in
+ // the call chain
+ Iterator methItr = moreMethodsToCheck.iterator();
while( methItr.hasNext() ) {
- MethodDescriptor md = (MethodDescriptor) methItr.next();
- descriptorsToVisit.add(md);
-
- // recursively find all callees from this task
- scheduleAllCallees(calleesScheduled, md);
+ Descriptor m = (Descriptor) methItr.next();
+ scheduleAllCallees(m);
}
}
// they call are updated
private void analyzeMethods() throws java.io.IOException {
+ descriptorsToVisit = (HashSet<Descriptor>)descriptorsToAnalyze.clone();
+
while( !descriptorsToVisit.isEmpty() ) {
Descriptor d = (Descriptor) descriptorsToVisit.iterator().next();
descriptorsToVisit.remove(d);
fm = state.getMethodFlat( (TaskDescriptor) d);
}
- OwnershipGraph og = analyzeFlatMethod(d, fm);
+ OwnershipGraph og = analyzeFlatMethod(d, fm);
OwnershipGraph ogPrev = mapDescriptorToCompleteOwnershipGraph.get(d);
if( !og.equals(ogPrev) ) {
mapDescriptorToCompleteOwnershipGraph.put(d, og);
- /*
- boolean writeLabels,
+ /* boolean writeLabels,
boolean labelSelect,
boolean pruneGarbage,
- boolean writeReferencers
- */
+ boolean writeReferencers */
og.writeGraph(d, true, true, true, false);
// only methods have dependents, tasks cannot
MethodDescriptor md = (MethodDescriptor) d;
Set dependents = callGraph.getCallerSet(md);
if( dependents != null ) {
- descriptorsToVisit.addAll(dependents);
+ Iterator depItr = dependents.iterator();
+ while( depItr.hasNext() ) {
+ Descriptor dependent = (Descriptor) depItr.next();
+ if( descriptorsToAnalyze.contains(dependent) ) {
+ descriptorsToVisit.add(dependent);
+ }
+ }
}
}
}
}
- int x = 0;
-
-
// keep passing the Descriptor of the method along for debugging
// and dot file writing
private OwnershipGraph
flatNodesToVisit = new HashSet<FlatNode>();
flatNodesToVisit.add(flatm);
+
+ // A YUCKY HACK--this is to make sure that an initially empty
+ // graph (no parameters) will get passed the first "any changes?"
+ // test when it comes up for analysis. It's ugly but throwing
+ // a child in works.
+ FlatNode fnJ = flatm.getNext(0);
+ assert fnJ != null;
+ flatNodesToVisit.add(fnJ);
+
+
// initilize the mapping of flat nodes in this flat method to
// ownership graph results to an empty mapping
mapFlatNodeToOwnershipGraph = new Hashtable<FlatNode, OwnershipGraph>();
// the final ownership graph result to return as an empty set
returnNodesToCombineForCompleteOwnershipGraph = new HashSet<FlatReturnNode>();
+
while( !flatNodesToVisit.isEmpty() ) {
FlatNode fn = (FlatNode) flatNodesToVisit.iterator().next();
flatNodesToVisit.remove(fn);
if( !og.equals(ogPrev) ) {
setGraphForFlatNode(fn, og);
-
-
- x++;
- if( x > 0 ) {
- String s = String.format("debug%04d", x);
- //og.writeGraph( s, true, true, true, false );
- }
-
-
-
for( int i = 0; i < fn.numNext(); i++ ) {
FlatNode nn = fn.getNext(i);
flatNodesToVisit.add(nn);
HashSet<FlatReturnNode> setRetNodes,
OwnershipGraph og) throws java.io.IOException {
- TempDescriptor src;
- TempDescriptor dst;
+ TempDescriptor lhs;
+ TempDescriptor rhs;
FieldDescriptor fld;
// use node type to decide what alterations to make
// adding parameters labels to new heap regions
for( int i = 0; i < fm.numParameters(); ++i ) {
TempDescriptor tdParam = fm.getParameter(i);
- og.assignParameterAllocationToTemp(methodDesc instanceof TaskDescriptor,
- tdParam,
- new Integer(i) );
- }
+ og.assignTempEqualToParamAlloc(tdParam,
+ methodDesc instanceof TaskDescriptor,
+ new Integer(i) );
+ }
break;
case FKind.FlatOpNode:
FlatOpNode fon = (FlatOpNode) fn;
if( fon.getOp().getOp() == Operation.ASSIGN ) {
- src = fon.getLeft();
- dst = fon.getDest();
- og.assignTempYToTempX(src, dst);
+ lhs = fon.getDest();
+ rhs = fon.getLeft();
+ og.assignTempXEqualToTempY(lhs, rhs);
}
break;
case FKind.FlatFieldNode:
FlatFieldNode ffn = (FlatFieldNode) fn;
- src = ffn.getSrc();
- dst = ffn.getDst();
+ lhs = ffn.getDst();
+ rhs = ffn.getSrc();
fld = ffn.getField();
if( !fld.getType().isPrimitive() ) {
- og.assignTempYFieldFToTempX(src, fld, dst);
+ og.assignTempXEqualToTempYFieldF(lhs, rhs, fld);
}
break;
case FKind.FlatSetFieldNode:
FlatSetFieldNode fsfn = (FlatSetFieldNode) fn;
- src = fsfn.getSrc();
- dst = fsfn.getDst();
+ lhs = fsfn.getDst();
fld = fsfn.getField();
- og.assignTempYToTempXFieldF(src, dst, fld);
+ rhs = fsfn.getSrc();
+ og.assignTempXFieldFEqualToTempY(lhs, fld, rhs);
+ break;
+
+ case FKind.FlatElementNode:
+ FlatElementNode fen = (FlatElementNode) fn;
+ lhs = fen.getDst();
+ rhs = fen.getSrc();
+ if( !lhs.getType().isPrimitive() ) {
+ og.assignTempXEqualToTempYFieldF(lhs, rhs, fdElement);
+ }
+ break;
+
+ case FKind.FlatSetElementNode:
+ FlatSetElementNode fsen = (FlatSetElementNode) fn;
+ lhs = fsen.getDst();
+ rhs = fsen.getSrc();
+ if( !rhs.getType().isPrimitive() ) {
+ og.assignTempXFieldFEqualToTempY(lhs, fdElement, rhs);
+ }
break;
case FKind.FlatNew:
FlatNew fnn = (FlatNew) fn;
- dst = fnn.getDst();
+ lhs = fnn.getDst();
AllocationSite as = getAllocationSiteFromFlatNewPRIVATE(fnn);
- og.assignNewAllocationToTempX(dst, as);
+ og.assignTempEqualToNewAlloc(lhs, as);
break;
case FKind.FlatCall:
- FlatCall fc = (FlatCall) fn;
- MethodDescriptor md = fc.getMethod();
- FlatMethod flatm = state.getMethodFlat(md);
- //HashSet<AllocationSite> allocSiteSet = getAllocationSiteSet( md );
- OwnershipGraph ogAllPossibleCallees = new OwnershipGraph(allocationDepth);
+ FlatCall fc = (FlatCall) fn;
+ MethodDescriptor md = fc.getMethod();
+ FlatMethod flatm = state.getMethodFlat(md);
+ OwnershipGraph ogMergeOfAllPossibleCalleeResults = new OwnershipGraph(allocationDepth);
if( md.isStatic() ) {
// a static method is simply always the same, makes life easy
OwnershipGraph onlyPossibleCallee = mapDescriptorToCompleteOwnershipGraph.get(md);
- ogAllPossibleCallees.merge(onlyPossibleCallee);
-
- /*
- if( onlyPossibleCallee != null ) {
- onlyPossibleCallee.writeGraph( "only", false, false );
- System.out.println( "There was only one possible callee, "+md );
- }
- */
-
+ ogMergeOfAllPossibleCalleeResults = og;
+ ogMergeOfAllPossibleCalleeResults.resolveMethodCall(fc, md.isStatic(), flatm, onlyPossibleCallee);
} else {
// if the method descriptor is virtual, then there could be a
// set of possible methods that will actually be invoked, so
- // find all of them and merge all of their graphs together
- TypeDescriptor typeDesc = fc.getThis().getType();
+ // find all of them and merge all of their results together
+ TypeDescriptor typeDesc = fc.getThis().getType();
Set possibleCallees = callGraph.getMethods(md, typeDesc);
- //int j = 0;
-
Iterator i = possibleCallees.iterator();
while( i.hasNext() ) {
MethodDescriptor possibleMd = (MethodDescriptor) i.next();
- //allocSiteSet.addAll( getAllocationSiteSet( possibleMd ) );
- OwnershipGraph ogPotentialCallee = mapDescriptorToCompleteOwnershipGraph.get(possibleMd);
- /*
- if( ogPotentialCallee != null ) {
- ogPotentialCallee.writeGraph( "potential"+j, false, false );
- ++j;
- }
- */
+ // don't alter the working graph (og) until we compute a result for every
+ // possible callee, merge them all together, then set og to that
+ OwnershipGraph ogCopy = new OwnershipGraph(allocationDepth);
+ ogCopy.merge(og);
- ogAllPossibleCallees.merge(ogPotentialCallee);
+ OwnershipGraph ogPotentialCallee = mapDescriptorToCompleteOwnershipGraph.get(possibleMd);
+ ogCopy.resolveMethodCall(fc, md.isStatic(), flatm, ogPotentialCallee);
+ ogMergeOfAllPossibleCalleeResults.merge(ogCopy);
}
-
- //System.out.println( "There were "+j+" potential callees merged together." );
}
- //System.out.println( "AllocationSiteSet has "+allocSiteSet.size()+" items." );
-
- // now we should have the following information to resolve this method call:
- //
- // 1. A FlatCall fc to query for the caller's context (argument labels, etc)
- //
- // 2. Whether the method is static; if not we need to deal with the "this" pointer
- //
- // *******************************************************************************************
- // 3. The original FlatMethod flatm to query for callee's context (paramter labels)
- // NOTE! I assume FlatMethod before virtual dispatch accurately describes all possible methods!
- // *******************************************************************************************
- //
- // 4. The OwnershipGraph ogAllPossibleCallees is a merge of every ownership graph of all the possible
- // methods to capture any possible references made.
- //
- // 5. The Set of AllocationSite objects, allocSiteSet that is the set of allocation sites from
- // every possible method we might have chosen
- //
- og.resolveMethodCall(fc, md.isStatic(), flatm, ogAllPossibleCallees);
+ og = ogMergeOfAllPossibleCalleeResults;
break;
case FKind.FlatReturnNode:
FlatReturnNode frn = (FlatReturnNode) fn;
+ rhs = frn.getReturnTemp();
+
+ if( rhs != null ) {
+ og.assignReturnEqualToTemp(rhs);
+ }
+
setRetNodes.add(frn);
break;
}
-
-
-
// return just the allocation site associated with one FlatNew node
private AllocationSite getAllocationSiteFromFlatNewPRIVATE(FlatNew fn) {
return asSetTotal;
}
-
-
-
- private HashSet<Integer> getHeapRegionIDset(OwnershipGraph og,
- int paramIndex) {
-
- assert og.paramIndex2id.containsKey(paramIndex);
- Integer idParam = og.paramIndex2id.get(paramIndex);
-
- HashSet<Integer> idSet = new HashSet<Integer>();
- idSet.add(idParam);
-
- return idSet;
- }
-
-
- private HashSet<Integer> getHeapRegionIDset(AllocationSite alloc) {
-
- HashSet<Integer> idSet = new HashSet<Integer>();
-
- for( int i = 0; i < alloc.getAllocationDepth(); ++i ) {
- Integer id = alloc.getIthOldest(i);
- idSet.add(id);
- }
-
- Integer idSummary = alloc.getSummary();
- idSet.add(idSummary);
-
- return idSet;
- }
-
- private HashSet<Integer> getHeapRegionIDset(HashSet<AllocationSite> allocSet) {
-
- HashSet<Integer> idSet = new HashSet<Integer>();
-
- Iterator allocItr = allocSet.iterator();
- while( allocItr.hasNext() ) {
- AllocationSite alloc = (AllocationSite) allocItr.next();
-
- for( int i = 0; i < alloc.getAllocationDepth(); ++i ) {
- Integer id = alloc.getIthOldest(i);
- idSet.add(id);
- }
-
- Integer idSummary = alloc.getSummary();
- idSet.add(idSummary);
- }
-
- return idSet;
- }
-
- private boolean createsPotentialAliases(OwnershipGraph og,
- HashSet<Integer> idSetA,
- HashSet<Integer> idSetB) {
- boolean potentialAlias = false;
-
- /*
- // first expand set B into the set of all heap region node ID's
- // reachable from the nodes in set B
- HashSet<Integer> idSetReachableFromB = og.getReachableSet( idSetB );
-
- // then see if anything in A can reach a node in the set reachable
- // from B. If so, there is a potential alias.
- Iterator i = idSetA.iterator();
- while( i.hasNext() ) {
- Integer id = (Integer) i.next();
- if( og.canIdReachSet( id, idSetB ) ) {
- return true;
- }
- }
- */
-
- return false;
- }
}
projects / IRC.git / blobdiff