Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java

   1 package Analysis.TaskStateAnalysis;
   2 import java.util.*;
   3 import IR.State;
   4 import IR.SymbolTable;
   5 import IR.ClassDescriptor;
   6 import java.io.File;
   7 import java.io.FileWriter;
   8 import java.io.FileOutputStream;
   9
  10 public class TaskGraph {
  11     TaskAnalysis taskanalysis;
  12     State state;
  13     Hashtable cdtonodes;
  14     Hashtable nodes;
  15
  16     public TaskGraph(State state, TaskAnalysis taskanalysis) {
  17         this.state=state;
  18         this.taskanalysis=taskanalysis;
  19         this.cdtonodes=new Hashtable();
  20
  21         for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext();) {
  22             ClassDescriptor cd=(ClassDescriptor) classit.next();
  23             if (cd.hasFlags())
  24                 produceTaskNodes(cd);
  25         }
  26     }
  27
  28
  29     public void createDOTfiles() {
  30         for(Iterator it_classes=(Iterator)cdtonodes.keys();it_classes.hasNext();) {
  31             ClassDescriptor cd=(ClassDescriptor) it_classes.next();
  32             Set tasknodes=getTaskNodes(cd);
  33             if (tasknodes!=null) {
  34                 try {
  35                     File dotfile_tasknodes=new File("graph"+cd.getSymbol()+"_task.dot");
  36                     FileOutputStream dotstream=new FileOutputStream(dotfile_tasknodes,true);
  37                     TaskNode.DOTVisitor.visit(dotstream,tasknodes);
  38                 } catch(Exception e) {
  39                     e.printStackTrace();
  40                     throw new Error();
  41                 }
  42             }
  43         }
  44     }
  45
  46     /** Returns the set of TaskNodes for the class descriptor cd */
  47
  48     public Set getTaskNodes(ClassDescriptor cd) {
  49         if (cdtonodes.containsKey(cd))
  50             return ((Hashtable)cdtonodes.get(cd)).keySet();
  51         else
  52             return null;
  53     }
  54
  55     private TaskNode canonicalizeTaskNode(Hashtable nodes, TaskNode node){
  56         if (nodes.containsKey(node))
  57             return (TaskNode)nodes.get(node);
  58         else{
  59             nodes.put(node,node);
  60             return (TaskNode)node;
  61         }
  62     }
  63
  64     private void produceTaskNodes(ClassDescriptor cd) {
  65         Set fsnodes=taskanalysis.getFlagStates(cd);
  66         if (fsnodes==null)
  67             return;
  68
  69         Hashtable<TaskNode,TaskNode> tasknodes=new Hashtable<TaskNode,TaskNode>();
  70         cdtonodes.put(cd, tasknodes);
  71
  72         for(Iterator it=fsnodes.iterator();it.hasNext();) {
  73             FlagState fs=(FlagState)it.next();
  74             Iterator it_inedges=fs.inedges();
  75             TaskNode tn,sn;
  76
  77                 if (fs.isSourceNode()) {
  78                         sn=new TaskNode("Start Node");
  79                         if(fs.edges().hasNext()){
  80                                  addEdges(fs,sn);
  81                         }
  82                 }
  83
  84                 while(it_inedges.hasNext()){
  85
  86                     FEdge inedge=(FEdge)it_inedges.next();
  87                     tn=new TaskNode(inedge.getLabel());
  88                     if(fs.edges().hasNext()){
  89                         addEdges(fs,tn);
  90                         }
  91             }
  92         }
  93     }
  94
  95   /*    private void mergeAllNodes(){
  96                 Hashtable alltasks=new Hashtable();
  97                 for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext();) {
  98                 ClassDescriptor cd=(ClassDescriptor) classit.next();
  99                         Set tnodes=((Hashtable)cdtonodes.get(cd)).keyset();
 100                         while (it_tnodes=tnodes.iterator();it_nodes.hasNext()){
 101                                 TaskNode tn=it_nodes.next();
 102                                 if (alltasks.containsKey(tn)){
 103                                         while(tn.
 104                                 }
 105                         }
 106
 107
 108
 109
 110     }
 111
 112          */
 113
 114     private void addEdges(FlagState fs, TaskNode tn){
 115
 116             Hashtable<TaskNode,TaskNode> tasknodes=(Hashtable<TaskNode,TaskNode>)cdtonodes.get(fs.getClassDescriptor());
 117             tn=(TaskNode)canonicalizeTaskNode(tasknodes, tn);
 118                 for (Iterator it_edges=fs.edges();it_edges.hasNext();){
 119                         TaskNode target=new TaskNode(((FEdge)it_edges.next()).getLabel());
 120                         target=(TaskNode)canonicalizeTaskNode(tasknodes,target);
 121
 122                         TEdge newedge=new TEdge(target);
 123                         if (! tn.edgeExists(newedge))
 124                                 tn.addEdge(new TEdge(target));
 125             }
 126
 127         }
 128
 129
 130 }