// keep current descriptors to visit in fixed-point interprocedural analysis,
private Stack<MethodDescriptor> methodDescriptorsToVisitStack;
+ // map a descriptor to a naive lattice
+ private Map<Descriptor, SSJavaLattice<String>> desc2naiveLattice;
+
// map a class descriptor to a field lattice
private Map<ClassDescriptor, SSJavaLattice<String>> cd2lattice;
// map a method/class descriptor to a skeleton hierarchy graph with combination nodes
private Map<Descriptor, HierarchyGraph> mapDescriptorToCombineSkeletonHierarchyGraph;
- // map a descriptor to a simple lattice
- private Map<Descriptor, SSJavaLattice<String>> mapDescriptorToSimpleLattice;
+ // map a descriptor to a skeleton lattice
+ private Map<Descriptor, SSJavaLattice<String>> mapDescriptorToSkeletonLattice;
// map a method descriptor to the set of method invocation nodes which are
// invoked by the method descriptor
this.mapMethodDescriptorToFlowGraph = new HashMap<MethodDescriptor, FlowGraph>();
this.cd2lattice = new HashMap<ClassDescriptor, SSJavaLattice<String>>();
this.md2lattice = new HashMap<MethodDescriptor, SSJavaLattice<String>>();
+ this.desc2naiveLattice = new HashMap<Descriptor, SSJavaLattice<String>>();
+
this.methodDescriptorsToVisitStack = new Stack<MethodDescriptor>();
this.mapMethodDescriptorToMethodInvokeNodeSet =
new HashMap<MethodDescriptor, Set<MethodInvokeNode>>();
this.mapDescriptorToCombineSkeletonHierarchyGraph = new HashMap<Descriptor, HierarchyGraph>();
this.mapDescriptorToSimpleHierarchyGraph = new HashMap<Descriptor, HierarchyGraph>();
- this.mapDescriptorToSimpleLattice = new HashMap<Descriptor, SSJavaLattice<String>>();
+ this.mapDescriptorToSkeletonLattice = new HashMap<Descriptor, SSJavaLattice<String>>();
this.mapDescToLocationSummary = new HashMap<Descriptor, LocationSummary>();
// + locOrder.getKeySet().size() + "\t" + hg.getNodeSet().size());
}
- System.out.println("The number of elements: Naive=" + numLocationsNaive + " SInfer="
- + numLocationsSInfer);
+ if (state.SSJAVA_INFER_NAIVE_WRITEDOTS) {
+ System.out.println("The number of elements: Naive=" + numLocationsNaive);
+ }
+ System.out.println("The number of elements: SInfer=" + numLocationsSInfer);
System.exit(0);
while (!methodDescList.isEmpty()) {
MethodDescriptor md = methodDescList.removeLast();
- // System.out.println("\n#updateCompositeLocationAssignments=" + md);
+ System.out.println("\n#updateCompositeLocationAssignments=" + md);
FlowGraph flowGraph = getFlowGraph(md);
Set<FlowNode> nodeSet = flowGraph.getNodeSet();
for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
FlowNode node = (FlowNode) iterator.next();
- // System.out.println("-node=" + node + " node.getDescTuple=" + node.getDescTuple());
+ System.out.println("-node=" + node + " node.getDescTuple=" + node.getDescTuple());
if (node.getCompositeLocation() != null) {
CompositeLocation compLoc = node.getCompositeLocation();
CompositeLocation updatedCompLoc = updateCompositeLocation(compLoc);
node.setCompositeLocation(updatedCompLoc);
- // System.out.println("---updatedCompLoc1=" + updatedCompLoc);
+ System.out.println("---updatedCompLoc1=" + updatedCompLoc);
} else {
NTuple<Descriptor> descTuple = node.getDescTuple();
// System.out.println("update desc=" + descTuple);
HierarchyGraph scGraph = getSimpleHierarchyGraph(enclosingDesc);
if (scGraph != null) {
HNode curNode = scGraph.getCurrentHNode(nodeIdentifier);
- // System.out.println("nodeID=" + nodeIdentifier + " curNode=" + curNode
- // + " enclosingDesc=" + enclosingDesc);
+ System.out.println(" nodeID=" + nodeIdentifier + " curNode=" + curNode
+ + " enclosingDesc=" + enclosingDesc);
if (curNode != null) {
nodeIdentifier = curNode.getName();
}
globalFlowGraph.addMapLocationToInferCompositeLocation(targetLocalLoc, newCompLoc);
// }
+ // if (node.getLocTuple().get(0).getDescriptor().getSymbol().equals("get_scale_factors")
+ // || node.getLocTuple().get(0).getDescriptor().getSymbol()
+ // .equals("get_LSF_scale_data")){
+ // Set<GlobalFlowNode> debugInNodeSet =
+ // globalFlowGraph.debug_getIncomingNodeSetFromPrefix(node, curPrefix);
+ // }
continue next;
// }
private void debug_writeLattices() {
- Set<Descriptor> keySet = mapDescriptorToSimpleLattice.keySet();
+ Set<Descriptor> keySet = mapDescriptorToSkeletonLattice.keySet();
for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
Descriptor key = (Descriptor) iterator.next();
- SSJavaLattice<String> simpleLattice = mapDescriptorToSimpleLattice.get(key);
+ SSJavaLattice<String> skeletonLattice = mapDescriptorToSkeletonLattice.get(key);
// HierarchyGraph simpleHierarchyGraph = getSimpleHierarchyGraph(key);
HierarchyGraph scHierarchyGraph = getSkeletonCombinationHierarchyGraph(key);
if (key instanceof ClassDescriptor) {
- // writeInferredLatticeDotFile((ClassDescriptor) key, scHierarchyGraph, simpleLattice,
- // "_SIMPLE");
+ writeInferredLatticeDotFile((ClassDescriptor) key, skeletonLattice, "_SKELETON");
} else if (key instanceof MethodDescriptor) {
MethodDescriptor md = (MethodDescriptor) key;
- // writeInferredLatticeDotFile(md.getClassDesc(), md, scHierarchyGraph, simpleLattice,
- // "_SIMPLE");
+ writeInferredLatticeDotFile(md.getClassDesc(), md, skeletonLattice, "_SKELETON");
}
LocationSummary ls = getLocationSummary(key);
for (Iterator iterator = cdKeySet.iterator(); iterator.hasNext();) {
ClassDescriptor cd = (ClassDescriptor) iterator.next();
// System.out.println("########cd=" + cd);
- writeInferredLatticeDotFile((ClassDescriptor) cd, getSkeletonCombinationHierarchyGraph(cd),
- cd2lattice.get(cd), "");
+ writeInferredLatticeDotFile((ClassDescriptor) cd, cd2lattice.get(cd), "");
COUNT += cd2lattice.get(cd).getKeySet().size();
}
Set<MethodDescriptor> mdKeySet = md2lattice.keySet();
for (Iterator iterator = mdKeySet.iterator(); iterator.hasNext();) {
MethodDescriptor md = (MethodDescriptor) iterator.next();
- writeInferredLatticeDotFile(md.getClassDesc(), md, getSkeletonCombinationHierarchyGraph(md),
- md2lattice.get(md), "");
+ writeInferredLatticeDotFile(md.getClassDesc(), md, md2lattice.get(md), "");
COUNT += md2lattice.get(md).getKeySet().size();
}
System.out.println("###COUNT=" + COUNT);
+
+ Set<Descriptor> descKeySet = desc2naiveLattice.keySet();
+ for (Iterator iterator = descKeySet.iterator(); iterator.hasNext();) {
+ Descriptor desc = (Descriptor) iterator.next();
+ // System.out.println("########cd=" + cd);
+
+ ClassDescriptor cd_naive;
+ MethodDescriptor md_naive;
+ if (desc instanceof ClassDescriptor) {
+ cd_naive = (ClassDescriptor) desc;
+ md_naive = null;
+ } else {
+ md_naive = (MethodDescriptor) desc;
+ cd_naive = md_naive.getClassDesc();
+ }
+
+ writeInferredLatticeDotFile(cd_naive, md_naive, desc2naiveLattice.get(desc), "_naive");
+ }
}
private void buildLattice(Descriptor desc) {
// System.out.println("buildLattice=" + desc);
- SSJavaLattice<String> simpleLattice = buildLattice.buildLattice(desc);
+ SSJavaLattice<String> skeletonLattice = buildLattice.buildLattice(desc);
- addMapDescToSimpleLattice(desc, simpleLattice);
+ addMapDescToSkeletonLattice(desc, skeletonLattice);
+
+ // write a dot file before everything is done
+ if (desc instanceof ClassDescriptor) {
+ writeInferredLatticeDotFile((ClassDescriptor) desc, null, skeletonLattice, "_SC");
+ } else {
+ MethodDescriptor md = (MethodDescriptor) desc;
+ writeInferredLatticeDotFile(md.getClassDesc(), md, skeletonLattice, "_SC");
+ }
HierarchyGraph simpleHierarchyGraph = getSimpleHierarchyGraph(desc);
+
// System.out.println("\n## insertIntermediateNodesToStraightLine:"
// + simpleHierarchyGraph.getName());
SSJavaLattice<String> lattice =
- buildLattice.insertIntermediateNodesToStraightLine(desc, simpleLattice);
+ buildLattice.insertIntermediateNodesToStraightLine(desc, skeletonLattice);
+
+ if (lattice == null) {
+ return;
+ }
lattice.removeRedundantEdges();
+ LocationInference.numLocationsSInfer += lattice.getKeySet().size();
+ System.out.println(desc + " numPaths=" + lattice.countPaths());
+
if (desc instanceof ClassDescriptor) {
// field lattice
cd2lattice.put((ClassDescriptor) desc, lattice);
- // ssjava.writeLatticeDotFile((ClassDescriptor) desc, null, lattice);
+ ssjava.writeLatticeDotFile((ClassDescriptor) desc, null, lattice);
} else if (desc instanceof MethodDescriptor) {
// method lattice
md2lattice.put((MethodDescriptor) desc, lattice);
MethodDescriptor md = (MethodDescriptor) desc;
ClassDescriptor cd = md.getClassDesc();
- // ssjava.writeLatticeDotFile(cd, md, lattice);
+ ssjava.writeLatticeDotFile(cd, md, lattice);
}
}
+ // deprecated: it builds method/class lattices without considering class inheritance
private void buildLattice() {
Set<Descriptor> keySet = mapDescriptorToCombineSkeletonHierarchyGraph.keySet();
SSJavaLattice<String> simpleLattice = buildLattice.buildLattice(desc);
- addMapDescToSimpleLattice(desc, simpleLattice);
+ addMapDescToSkeletonLattice(desc, simpleLattice);
HierarchyGraph simpleHierarchyGraph = getSimpleHierarchyGraph(desc);
System.out.println("\n## insertIntermediateNodesToStraightLine:"
}
- public void addMapDescToSimpleLattice(Descriptor desc, SSJavaLattice<String> lattice) {
- mapDescriptorToSimpleLattice.put(desc, lattice);
+ public void addMapDescToSkeletonLattice(Descriptor desc, SSJavaLattice<String> lattice) {
+ mapDescriptorToSkeletonLattice.put(desc, lattice);
}
- public SSJavaLattice<String> getSimpleLattice(Descriptor desc) {
- return mapDescriptorToSimpleLattice.get(desc);
+ public SSJavaLattice<String> getSkeletonLattice(Descriptor desc) {
+ return mapDescriptorToSkeletonLattice.get(desc);
}
private void simplifyHierarchyGraph() {
HierarchyGraph simpleHierarchyGraph = getHierarchyGraph(desc).clone();
simpleHierarchyGraph.setName(desc + "_SIMPLE");
simpleHierarchyGraph.removeRedundantEdges();
+ // simpleHierarchyGraph.removeIsolatedNodes();
mapDescriptorToSimpleHierarchyGraph.put(desc, simpleHierarchyGraph);
}
}
System.out.println("\nSSJAVA: Inserting Combination Nodes:" + desc);
HierarchyGraph skeletonGraph = getSkeletonHierarchyGraph(desc);
HierarchyGraph skeletonGraphWithCombinationNode = skeletonGraph.clone();
+ skeletonGraphWithCombinationNode.setSCGraph(true);
skeletonGraphWithCombinationNode.setName(desc + "_SC");
HierarchyGraph simpleHierarchyGraph = getSimpleHierarchyGraph(desc);
// if the srcNode is started with the global descriptor
// need to set as a skeleton node
if (!hasGlobalAccess && srcNode.getDescTuple().startsWith(GLOBALDESC)) {
+ System.out.println("SRCNODE=" + srcNode);
hasGlobalAccess = true;
}
// set hasGloabalAccess true in the method summary.
if (hasGlobalAccess) {
getMethodSummary(md).setHasGlobalAccess();
+ methodGraph.getHNode(GLOBALDESC).setSkeleton(true);
}
- methodGraph.getHNode(GLOBALDESC).setSkeleton(true);
if (ssjava.getMethodContainingSSJavaLoop().equals(md)) {
// if the current method contains the event loop
}
- public void writeInferredLatticeDotFile(ClassDescriptor cd, HierarchyGraph simpleHierarchyGraph,
- SSJavaLattice<String> locOrder, String nameSuffix) {
+ public void writeInferredLatticeDotFile(ClassDescriptor cd, SSJavaLattice<String> locOrder,
+ String nameSuffix) {
// System.out.println("@cd=" + cd);
// System.out.println("@sharedLoc=" + locOrder.getSharedLocSet());
- writeInferredLatticeDotFile(cd, null, simpleHierarchyGraph, locOrder, nameSuffix);
+ writeInferredLatticeDotFile(cd, null, locOrder, nameSuffix);
}
public void writeInferredLatticeDotFile(ClassDescriptor cd, MethodDescriptor md,
- HierarchyGraph simpleHierarchyGraph, SSJavaLattice<String> locOrder, String nameSuffix) {
+ SSJavaLattice<String> locOrder, String nameSuffix) {
String fileName = "lattice_";
if (md != null) {
String lowLocId = pair.getSecond();
if (!addedLocSet.contains(highLocId)) {
addedLocSet.add(highLocId);
- drawNode(bw, locOrder, simpleHierarchyGraph, highLocId);
+ drawNode(bw, locOrder, highLocId);
}
if (!addedLocSet.contains(lowLocId)) {
addedLocSet.add(lowLocId);
- drawNode(bw, locOrder, simpleHierarchyGraph, lowLocId);
+ drawNode(bw, locOrder, lowLocId);
}
bw.write(highLocId + " -> " + lowLocId + ";\n");
return str;
}
- private void drawNode(BufferedWriter bw, SSJavaLattice<String> lattice, HierarchyGraph graph,
- String locName) throws IOException {
+ public void addNaiveLattice(Descriptor desc, SSJavaLattice<String> lattice) {
+ desc2naiveLattice.put(desc, lattice);
+ }
+
+ private void drawNode(BufferedWriter bw, SSJavaLattice<String> lattice, String locName)
+ throws IOException {
String prettyStr;
if (lattice.isSharedLoc(locName)) {
projects / IRC.git / blobdiff