color nodes to indicate whether they'll be collected

diff --git a/Robust/src/Analysis/TaskStateAnalysis/GarbageAnalysis.java b/Robust/src/Analysis/TaskStateAnalysis/GarbageAnalysis.java
new file mode 100644 (file)
index 0000000..46cdfb9
--- /dev/null
+++ b/Robust/src/Analysis/TaskStateAnalysis/GarbageAnalysis.java
@@ -0,0 +1,81 @@
+package Analysis.TaskStateAnalysis;
+import IR.*;
+import Util.Namer;
+import java.util.*;
+import Util.GraphNode;
+import Util.Edge;
+
+public class GarbageAnalysis extends Namer {
+    State state;
+    TaskAnalysis taskanalysis;
+    HashSet garbagestates;
+    HashSet possiblegarbagestates;
+
+
+    public GarbageAnalysis(State state, TaskAnalysis taskanalysis) {
+       this.state=state;
+       this.taskanalysis=taskanalysis;
+       this.garbagestates=new HashSet();
+       this.possiblegarbagestates=new HashSet();
+       doAnalysis();
+    }
+   
+    public void doAnalysis() {
+       for(Iterator it=state.getClassSymbolTable().getDescriptorsIterator();it.hasNext();) {
+           ClassDescriptor cd=(ClassDescriptor) it.next();
+           if (taskanalysis.getFlagStates(cd)==null)
+               continue;
+           analyzeClass(cd);
+       }
+    }
+
+    public void analyzeClass(ClassDescriptor cd) {
+       Set flagstatenodes=taskanalysis.getFlagStates(cd);
+       HashSet garbage=new HashSet();
+       HashSet possiblegarbage=new HashSet();
+
+       for(Iterator fsit=flagstatenodes.iterator();fsit.hasNext();) {
+           FlagState fs=(FlagState)fsit.next();
+           if (fs.numedges()==0)
+               garbage.add(fs);
+       }
+
+       Stack tovisit=new Stack();
+       tovisit.addAll(garbage);
+       possiblegarbage.addAll(garbage);
+       while(!tovisit.isEmpty()) {
+           FlagState fs=(FlagState)tovisit.pop();
+           for(int i=0;i<fs.numinedges();i++) {
+               Edge e=fs.getinedge(i);
+               FlagState fsnew=(FlagState) e.getSource();
+               if (!possiblegarbage.contains(fsnew)) {
+                   possiblegarbage.add(fsnew);
+                   tovisit.push(fsnew);
+               }
+           }
+       }
+       garbagestates.addAll(garbage);
+       possiblegarbagestates.addAll(possiblegarbage);
+    }
+    
+    public String nodeLabel(GraphNode gn) {
+       return "";
+    }
+    
+    public String nodeOption(GraphNode gn) {
+       if (garbagestates.contains(gn)) {
+           return "color=green";
+       } else if (possiblegarbagestates.contains(gn)) {
+           return "color=blue";
+       } else
+           return "color=red";
+    }
+
+    public String edgeLabel(Edge e) {
+       return "";
+    }
+
+    public String edgeOption(Edge e) {
+       return "";
+    }
+}

diff --git a/Robust/src/Interface/WebInterface.java b/Robust/src/Interface/WebInterface.java
index 6b3a9834efe6ec4c012639598cf95cc193f70d9d..251d4a06888a07070f942449bb4c996dfeb55242 100644 (file)
--- a/Robust/src/Interface/WebInterface.java
+++ b/Robust/src/Interface/WebInterface.java
@@ -3,6 +3,7 @@ import java.io.*;
 import Analysis.TaskStateAnalysis.*;
 import IR.*;
 import java.util.*;
+import Util.Namer;
 
 public class WebInterface {
     TaskAnalysis taskanalysis;
@@ -10,11 +11,14 @@ public class WebInterface {
     State state;
     Hashtable taskmap;
     Hashtable taskgraphmap;
+    GarbageAnalysis garbageanalysis;
 
-    public WebInterface(State state, TaskAnalysis taskanalysis, TaskGraph taskgraph) {
+    public WebInterface(State state, TaskAnalysis taskanalysis, TaskGraph taskgraph, GarbageAnalysis garbageanalysis) {
        this.state=state;
        this.taskanalysis=taskanalysis;
        this.taskgraph=taskgraph;
+       this.garbageanalysis=garbageanalysis;
+
        taskmap=new Hashtable();
        taskgraphmap=new Hashtable();
     }
@@ -43,11 +47,14 @@ public class WebInterface {
     private String flagstate(ClassDescriptor cd, BufferedWriter out, HTTPResponse resp) {
        Set objects=taskanalysis.getFlagStates(cd);
        File file=new File(cd.getSymbol()+".dot");
+       Vector namers=new Vector();
+       namers.add(new Namer());
+       namers.add(garbageanalysis);
        try {
            //Generate jpg
            Runtime r=Runtime.getRuntime();
            FileOutputStream dotstream=new FileOutputStream(file,false);
-           FlagState.DOTVisitor.visit(dotstream, objects);
+           FlagState.DOTVisitor.visit(dotstream, objects, namers);
            dotstream.close();
            Process p=r.exec("dot -Tjpg "+cd.getSymbol()+".dot -o"+cd.getSymbol()+".jpg");
            p.waitFor();
@@ -99,7 +106,6 @@ public class WebInterface {
                pw.println("<br>");
                taskgraphmap.put("/"+cd.getSymbol()+"-t.html", cd);
            }
-
        }
        pw.flush();
        return null;

diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java
index 62e36426a2d063a0beed26a094e1eccda9fe68b0..e880f0f65ebc5880f288832a64ab25d880f75598 100644 (file)
--- a/Robust/src/Main/Main.java
+++ b/Robust/src/Main/Main.java
@@ -14,6 +14,7 @@ import Analysis.TaskStateAnalysis.TaskAnalysis;
 import Analysis.TaskStateAnalysis.TaskGraph;
 import Analysis.CallGraph.CallGraph;
 import Analysis.TaskStateAnalysis.TagAnalysis;
+import Analysis.TaskStateAnalysis.GarbageAnalysis;
 import Interface.*;
 
 public class Main {
@@ -111,25 +112,23 @@ public class Main {
       BuildFlat bf=new BuildFlat(state,tu);
       bf.buildFlat();
 
-      CallGraph callgraph=null;
-      TagAnalysis taganalysis=null;
-      TaskGraph tg=null;
-      TaskAnalysis ta=null;
-
       if (state.TASKSTATE) {
-         callgraph=new CallGraph(state);
-         taganalysis=new TagAnalysis(state, callgraph);
-         ta=new TaskAnalysis(state, taganalysis);
+         CallGraph callgraph=new CallGraph(state);
+         TagAnalysis taganalysis=new TagAnalysis(state, callgraph);
+         TaskAnalysis ta=new TaskAnalysis(state, taganalysis);
          ta.taskAnalysis();
-         tg=new TaskGraph(state, ta);
+         TaskGraph tg=new TaskGraph(state, ta);
          tg.createDOTfiles();
-      }
+         if (state.WEBINTERFACE) {
+             GarbageAnalysis ga=new GarbageAnalysis(state, ta);
+             WebInterface wi=new WebInterface(state, ta, tg, ga);
+             JhttpServer serve=new JhttpServer(8000,wi);
+             serve.run();
+         }
+
 
-      if (state.WEBINTERFACE) {
-         WebInterface wi=new WebInterface(state, ta, tg);
-         JhttpServer serve=new JhttpServer(8000,wi);
-         serve.run();
       }
+
       
       
       BuildCode bc=new BuildCode(state, bf.getMap(), tu);

diff --git a/Robust/src/Makefile b/Robust/src/Makefile
index f353ea7cb653f7c1ca54a68982d9ad6c3a3d227f..68fbe05fff6f26ea2a01ea2122904f4d4c03d9c6 100644 (file)
--- a/Robust/src/Makefile
+++ b/Robust/src/Makefile
@@ -53,6 +53,7 @@ Analysis/TaskStateAnalysis/TagBinding.class                           \
 Analysis/TaskStateAnalysis/TaskAnalysis.class                          \
 Analysis/TaskStateAnalysis/TaskNode.class                              \
 Analysis/TaskStateAnalysis/TaskGraph.class                             \
+Analysis/TaskStateAnalysis/GarbageAnalysis.class                       \
 Analysis/CallGraph/CallGraph.class Util/Edge.class                     \
 Util/GraphNode.class Util/Relation.class Util/Namer.class              \
 Interface/WebInterface.class Interface/HTTPHeader.class                        \