From: yeom Date: Wed, 27 Feb 2013 06:06:26 +0000 (+0000) Subject: all fixed... X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=74da1d0f330468f65e6d141d1732fc1f6e0bb38e;p=IRC.git all fixed... --- diff --git a/Robust/src/Analysis/SSJava/BuildLattice.java b/Robust/src/Analysis/SSJava/BuildLattice.java index aa8ac139..e24965e3 100644 --- a/Robust/src/Analysis/SSJava/BuildLattice.java +++ b/Robust/src/Analysis/SSJava/BuildLattice.java @@ -315,11 +315,15 @@ public class BuildLattice { // the current node is not a combination node // there is only one parent node which should be skeleton node. - System.out.println(" hierarchyGraph.getSkeleteNodeSetReachTo(" + hNode + ")=" - + hierarchyGraph.getSkeleteNodeSetReachTo(hNode)); - aboveSet.addAll(hierarchyGraph.getSkeleteNodeSetReachTo(hNode)); - System.out.println(" aboveset of " + hNode + "=" + aboveSet); - // assert aboveSet.size() == 1; + // System.out.println(" hierarchyGraph.getSkeleteNodeSetReachTo(" + hNode + ")=" + // + hierarchyGraph.getSkeleteNodeSetReachTo(hNode)); + + Set reachToSet = hierarchyGraph.getSkeleteNodeSetReachTo(hNode); + for (Iterator iterator2 = reachToSet.iterator(); iterator2.hasNext();) { + HNode reachToNode = (HNode) iterator2.next(); + aboveSet.add(scGraph.getCurrentHNode(reachToNode)); + } + SCNode = aboveSet.iterator().next(); } @@ -333,8 +337,8 @@ public class BuildLattice { trace = hierarchyGraph.computeDistance(hNode, endSet, combineSkeletonNodeSet); - System.out.println(" COUNT-RESULT::node=" + hNode + " above=" + endSet + " trace=" - + trace + " SCNode=" + SCNode); + System.out.println(" COUNT-RESULT::start=" + hNode + " end=" + endSet + " trace=" + + trace); } // 3) convert the node m into a chain of nodes with the last node in the chain having m’s diff --git a/Robust/src/Analysis/SSJava/HierarchyGraph.java b/Robust/src/Analysis/SSJava/HierarchyGraph.java index 145cf8af..3c598d4e 100644 --- a/Robust/src/Analysis/SSJava/HierarchyGraph.java +++ b/Robust/src/Analysis/SSJava/HierarchyGraph.java @@ -811,11 +811,10 @@ public class HierarchyGraph { Set> keySet = simpleHierarchyGraph.getCombineNodeSet(); for (Iterator iterator = keySet.iterator(); iterator.hasNext();) { Set combineSet = (Set) iterator.next(); - System.out.println("--combineSet=" + combineSet); HNode combinationNode = getCombinationNode(combineSet); - System.out.println("--combinationNode=" + combinationNode + " combineSet=" + combineSet); - - System.out.println("--hierarchynodes=" + System.out.println("\n@INSERT COMBINATION NODE FOR combineSet=" + combineSet + + " --combinationNode=" + combinationNode); + System.out.println(" --hierarchynodes=" + simpleHierarchyGraph.getCombinationNodeSetByCombineNodeSet(combineSet)); Set simpleHNodeSet = @@ -843,6 +842,14 @@ public class HierarchyGraph { if (isFirstNodeOfChain) { simpleHierarchyGraph.addFirstNodeOfChain(combineSet, simpleHNode); System.out.println("IT IS THE FIRST NODE OF THE CHAIN:" + simpleHNode); + // System.out.println("--->INCOMING NODES="); + // Set inNodeSet = simpleHierarchyGraph.getIncomingNodeSet(simpleHNode); + // for (Iterator iterator3 = inNodeSet.iterator(); iterator3.hasNext();) { + // HNode inNode = (HNode) iterator3.next(); + // System.out.println(" inNode=" + inNode + " combineSet=" + // + simpleHierarchyGraph.getCombineSetByCombinationNode(inNode) + " SKELETON TO SET=" + // + simpleHierarchyGraph.getSkeleteNodeSetReachTo(inNode)); + // } } } @@ -859,6 +866,7 @@ public class HierarchyGraph { srcNode = getHNode(inSkeletonNode.getDescriptor()); } // System.out.println("--srcNode=" + srcNode); + System.out.println(" ADD EDGE SRC=" + srcNode + " -> " + combinationNode); addEdgeWithNoCycleCheck(srcNode, combinationNode); } @@ -897,7 +905,8 @@ public class HierarchyGraph { // because the node is not directly connected to the combination node // removeRedundantReachToNodes(reachToSet); - return reachToSet; + return removeTransitivelyReachToSet(reachToSet); + // return reachToSet; } private void recurSkeletonReachTo(HNode node, Set reachToSet, Set visited) { @@ -998,6 +1007,7 @@ public class HierarchyGraph { if (!node.isSkeleton()) { Set reachToSet = getSkeleteNodeSetReachTo(node); // Set tempSet = removeTransitivelyReachToSet(reachToSet); + // System.out.println("ALL REACH SET=" + reachToSet); // reachToSet = removeTransitivelyReachToSet(reachToSet); Set curReachToSet = new HashSet(); @@ -1006,7 +1016,7 @@ public class HierarchyGraph { curReachToSet.add(getCurrentHNode(reachSkeletonNode)); } - System.out.println("-curReachToSet=" + curReachToSet + " reachToSet=" + reachToSet); + // System.out.println("-curReachToSett=" + curReachToSet + " reachToSet=" + reachToSet); reachToSet = curReachToSet; // System.out.println("$node=" + node + " reachToNodeSet=" + reachToSet + " tempSet=" @@ -1413,7 +1423,8 @@ public class HierarchyGraph { } public Stack computeDistance(HNode startNode, Set endNodeSet, Set combineSet) { - System.out.println("#####computeDistance startNode=" + startNode + " endNode=" + endNodeSet); + // System.out.println("#####computeDistanceance startNode=" + startNode + " endNode=" + + // endNodeSet); Stack trace = new Stack(); return recur_computeDistance(startNode, endNodeSet, 0, combineSet, trace); } @@ -1429,7 +1440,6 @@ public class HierarchyGraph { } } - if (endNodeSet.contains(curNode)) { // it reaches to one of endNodeSet return trace; @@ -1452,11 +1462,11 @@ public class HierarchyGraph { } } - System.out.println(" traverse more to" + inNode + " before-trace=" + trace); + // System.out.println(" traverse more to" + inNode + " before-trace=" + trace); Stack newTrace = (Stack) trace.clone(); Stack curTrace = recur_computeDistance(inNode, endNodeSet, count, combineSet, newTrace); - System.out.println("curTrace=" + curTrace); + // System.out.println("curTracerTrace=" + curTrace); if (curTrace != null && curTrace.size() > curMaxDistance) { curMaxTrace = curTrace; @@ -1610,4 +1620,15 @@ public class HierarchyGraph { // HNode inNode = inNodeSet.iterator().next(); return -1; } + + public void removeIsolatedNodes() { + Set toberemoved = new HashSet(); + for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) { + HNode node = (HNode) iterator.next(); + if (getIncomingNodeSet(node).isEmpty() && getOutgoingNodeSet(node).isEmpty()) { + toberemoved.add(node); + } + } + nodeSet.removeAll(toberemoved); + } } diff --git a/Robust/src/Analysis/SSJava/LocationInference.java b/Robust/src/Analysis/SSJava/LocationInference.java index 3adfeebe..e951c1a9 100644 --- a/Robust/src/Analysis/SSJava/LocationInference.java +++ b/Robust/src/Analysis/SSJava/LocationInference.java @@ -2634,6 +2634,7 @@ public class LocationInference { lattice.removeRedundantEdges(); LocationInference.numLocationsSInfer += lattice.getKeySet().size(); + System.out.println(desc + " numPaths=" + lattice.countPaths()); if (desc instanceof ClassDescriptor) { // field lattice @@ -2772,6 +2773,7 @@ public class LocationInference { HierarchyGraph simpleHierarchyGraph = getHierarchyGraph(desc).clone(); simpleHierarchyGraph.setName(desc + "_SIMPLE"); simpleHierarchyGraph.removeRedundantEdges(); + // simpleHierarchyGraph.removeIsolatedNodes(); mapDescriptorToSimpleHierarchyGraph.put(desc, simpleHierarchyGraph); } } @@ -3202,6 +3204,7 @@ public class LocationInference { // 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; } @@ -3313,8 +3316,8 @@ public class LocationInference { // 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 diff --git a/Robust/src/Analysis/SSJava/SSJavaLattice.java b/Robust/src/Analysis/SSJava/SSJavaLattice.java index ae875777..406b72ec 100644 --- a/Robust/src/Analysis/SSJava/SSJavaLattice.java +++ b/Robust/src/Analysis/SSJava/SSJavaLattice.java @@ -336,8 +336,6 @@ public class SSJavaLattice extends Lattice { } } - - public SSJavaLattice clone() { SSJavaLattice clone = new SSJavaLattice(getTopItem(), getBottomItem()); @@ -346,4 +344,39 @@ public class SSJavaLattice extends Lattice { return clone; } + public int countPaths() { + T bottom = getBottomItem(); + + Map> map = getIncomingElementMap(); + Map countMap = new HashMap(); + + Set visited = new HashSet(); + visited.add(bottom); + + countMap.put(bottom, new Integer(1)); + recur_countPaths(bottom, map, countMap, visited); + if (countMap.containsKey(getTopItem())) { + return countMap.get(getTopItem()); + } + return 0; + } + + private void recur_countPaths(T cur, Map> map, Map countMap, Set visited) { + int curCount = countMap.get(cur).intValue(); + Set inSet = map.get(cur); + + for (Iterator iterator = inSet.iterator(); iterator.hasNext();) { + T in = (T) iterator.next(); + int inCount = 0; + if (countMap.containsKey(in)) { + inCount = countMap.get(in).intValue(); + } + inCount += curCount; + countMap.put(in, inCount); + if (visited.containsAll(get(in))) { + visited.add(in); + recur_countPaths(in, map, countMap, visited); + } + } + } }