}
public String toStringForDOT() {
+ String s = "";
if( disjointId != null ) {
- return "disjoint "+disjointId+"\\n"+toString()+
- "\\n"+getType().toPrettyString();
- } else {
- return toString()+
- "\\n"+getType().toPrettyString();
+ s += "disjoint "+disjointId+"\\n";
}
+ s += toString()+"\\n";
+
+ // jjenista -- too lazy to make this a compiler option right now
+ // But here's the rub: getting the source file and line number of
+ // each allocation site in the graph is awesome except it blows up
+ // the size of the image dramatically: only turn it on when you
+ // need it.!
+
+ //String filename = DisjointAnalysis.fn2filename.get( flatNew );
+ //if( filename != null ) {
+ // s += DisjointAnalysis.fn2filename.get( flatNew )+":"+
+ // flatNew.getNumLine()+"\\n";
+ //}
+
+ return s + getType().toPrettyString();
}
public String toStringWithIDs() {
Accessible accessible;
+
+ // for debugging, which source file is this allocation in?
+ public static Hashtable<FlatNode, String> fn2filename;
+
// we construct an entry method of flat nodes complete
// with a new allocation site to model the command line
fc2enclosing = new Hashtable<FlatCall, Descriptor>();
+ fn2filename = new Hashtable<FlatNode, String>();
+
if( summarizePerClass ) {
mapTypeToAllocSite = new Hashtable<TypeDescriptor, AllocSite>();
typesToFlag = new HashSet<TypeDescriptor>();
" methods and "+totalNodeVisits+" nodes.";
}
if( state.DISJOINT_COUNT_GRAPH_ELEMENTS ) {
- treport += "\n"+getPartial( mdSourceEntry ).countGraphElements()+"\n";
- getPartial( mdSourceEntry ).writeGraph( "countElementsGraph",
- true,
- true,
- true,
- false,
- true,
- true,
- true );
- getPartial( mdSourceEntry ).writeNodes( "countElementsNodeListing.txt" );
+ GraphElementCount gec = new GraphElementCount();
+ for( Descriptor d : descriptorsToAnalyze ) {
+ getPartial( d ).countGraphElements( gec );
+ }
+ treport += "\n"+gec+"\n";
}
String justtime = String.format("%.2f", dt);
System.out.println(treport);
case FKind.FlatNew:
FlatNew fnn = (FlatNew) fn;
+
+ recordFilename( fn, fmContaining );
+
lhs = fnn.getDst();
if( shouldAnalysisTrack(lhs.getType() ) ) {
AllocSite as = getAllocSiteFromFlatNewPRIVATE(fnn);
return rgAtExit.canPointTo( x, arrayElementFieldName, x.getType().dereference() );
}
+
+
+ private void recordFilename( FlatNode fn, FlatMethod fmContaining ) {
+ ClassDescriptor cd = fmContaining.getMethod().getClassDesc();
+ String filename = "UNKNOWNFILE";
+ if( cd != null ) {
+ String s = cd.getSourceFileName();
+ if( s != null ) {
+ filename = s;
+ }
+ }
+ fn2filename.put( fn, filename );
+ }
+
+
// to evaluate convergence behavior
private static long totalMethodVisits = 0;
--- /dev/null
+package Analysis.Disjoint;
+
+import IR.*;
+import IR.Flat.*;
+import java.util.*;
+
+
+public class GraphElementCount {
+
+ public long numNodes;
+ public long numEdges;
+ public long numNodeStates;
+ public long numEdgeStates;
+ public long numNodeStateNonzero;
+ public long numEdgeStateNonzero;
+
+ public GraphElementCount() {
+ numNodes = 0;
+ numEdges = 0;
+ numNodeStates = 0;
+ numEdgeStates = 0;
+ numNodeStateNonzero = 0;
+ numEdgeStateNonzero = 0;
+ }
+
+ public void nodeInc( long amount ) {
+ numNodes += amount;
+ }
+
+ public void edgeInc( long amount ) {
+ numEdges += amount;
+ }
+
+ public void nodeStateInc( long amount ) {
+ numNodeStates += amount;
+ }
+
+ public void edgeStateInc( long amount ) {
+ numEdgeStates += amount;
+ }
+
+ public void nodeStateNonzeroInc( long amount ) {
+ numNodeStateNonzero += amount;
+ }
+
+ public void edgeStateNonzeroInc( long amount ) {
+ numEdgeStateNonzero += amount;
+ }
+
+ public String toString() {
+ return
+ "################################################\n"+
+ "Nodes = "+numNodes+"\n"+
+ "Edges = "+numEdges+"\n"+
+ "Node states = "+numNodeStates+"\n"+
+ "Edge states = "+numEdgeStates+"\n"+
+ "Node non-zero tuples = "+numNodeStateNonzero+"\n"+
+ "Edge non-zero tuples = "+numEdgeStateNonzero+"\n"+
+ "################################################\n";
+ }
+}
return isOutOfContext;
}
+ public boolean isShadow() {
+ return id < 0;
+ }
public Iterator<RefEdge> iteratorToReferencers() {
return referencers.iterator();
}
- public String countGraphElements() {
- long numNodes = 0;
- long numEdges = 0;
- long numNodeStates = 0;
- long numEdgeStates = 0;
- long numNodeStateNonzero = 0;
- long numEdgeStateNonzero = 0;
+ public void countGraphElements( GraphElementCount c ) {
for( HeapRegionNode node : id2hrn.values() ) {
- numNodes++;
- numNodeStates += node.getAlpha().numStates();
- numNodeStateNonzero += node.getAlpha().numNonzeroTuples();
+
+ if( node.isShadow() || node.isWiped() ) {
+ // do not count nodes that are not functionally part of the
+ // abstraction (they are in the graph for implementation
+ // convenience when needed next)
+ continue;
+ }
+
+ c.nodeInc( 1 );
+ c.nodeStateInc( node.getAlpha().numStates() );
+ c.nodeStateNonzeroInc( node.getAlpha().numNonzeroTuples() );
// all edges in the graph point TO a heap node, so scanning
// all referencers of all nodes gets every edge
while( refItr.hasNext() ) {
RefEdge edge = refItr.next();
- numEdges++;
- numEdgeStates += edge.getBeta().numStates();
- numEdgeStateNonzero += edge.getBeta().numNonzeroTuples();
+ c.edgeInc( 1 );
+ c.edgeStateInc( edge.getBeta().numStates() );
+ c.edgeStateNonzeroInc( edge.getBeta().numNonzeroTuples() );
}
}
-
- return
- "################################################\n"+
- "Nodes = "+numNodes+"\n"+
- "Edges = "+numEdges+"\n"+
- "Node states = "+numNodeStates+"\n"+
- "Edge states = "+numEdgeStates+"\n"+
- "Node non-zero tuples = "+numNodeStateNonzero+"\n"+
- "Edge non-zero tuples = "+numEdgeStateNonzero+"\n"+
- "################################################\n";
}
// allocation site ID, full type, assigned heap node IDs
bw.write( as.toStringVerbose()+"\n"+
" "+as.toStringJustIDs()+"\n" );
+ bw.write( " on "+
+ DisjointAnalysis.fn2filename.get( as.getFlatNew() )+":"+
+ as.getFlatNew().getNumLine()+"\n" );
// which of the nodes are actually in this graph?
for( int i = 0; i < allocationDepth; ++i ) {
# EX: (skip first 10 visits, capture the next 3, then halt)
# -disjoint-debug-snap-method Remove 10 3 true
-DISJOINTDEBUG= -disjoint -disjoint-k 1 -enable-assertions $(DRELEASEMODE) \
+DISJOINTDEBUG= -disjoint -disjoint-k 1 -enable-assertions $(DRELEASEMODE) -printlinenum \
-justanalyze \
- -disjoint-count-graph-elements \
- -disjoint-disable-strong-update
+ -disjoint-count-graph-elements
+# -disjoint-disable-strong-update
# -disjoint-disable-global-sweep
# -disjoint-summarize-per-class
SOURCE_FILES=$(PROGRAM).java
BUILDSCRIPT=~/research/Robust/src/buildscript
-BSFLAGS= -joptimize \
+BSFLAGS= -joptimize -printlinenum \
-mainclass Test \
-justanalyze -disjoint -disjoint-k 1 -disjoint-write-dots final \
-disjoint-alias-file aliases.txt normal -enable-assertions \
projects / IRC.git / commitdiff