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 IR.TaskDescriptor;
   7 import java.io.File;
   8 import java.io.FileWriter;
   9 import java.io.FileOutputStream;
  10
  11 public class TaskGraph {
  12     TaskAnalysis taskanalysis;
  13     State state;
  14     Hashtable cdtonodes;
  15     Hashtable nodes;
  16     Hashtable<TaskNode,TaskNode> alltasknodes;
  17
  18     //Colors
  19     String colors[]={"red","blue","green","brown","orange","pink","black","brown","grey","olivedrab"};
  20
  21     public TaskGraph(State state, TaskAnalysis taskanalysis) {
  22         this.state=state;
  23         this.taskanalysis=taskanalysis;
  24         this.cdtonodes=new Hashtable();
  25         this.alltasknodes=new Hashtable<TaskNode,TaskNode>();
  26
  27         for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext();) {
  28             ClassDescriptor cd=(ClassDescriptor) classit.next();
  29             if (cd.hasFlags())
  30                 produceTaskNodes(cd);
  31         }
  32         produceAllTaskNodes();
  33     }
  34
  35
  36     public void createDOTfiles() {
  37         for(Iterator it_classes=(Iterator)cdtonodes.keys();it_classes.hasNext();) {
  38             ClassDescriptor cd=(ClassDescriptor) it_classes.next();
  39             Set tasknodes=getTaskNodes(cd);
  40             if (tasknodes!=null) {
  41                 try {
  42                     File dotfile_tasknodes=new File("graph"+cd.getSymbol()+"_task.dot");
  43                     FileOutputStream dotstream=new FileOutputStream(dotfile_tasknodes,true);
  44                     TaskNode.DOTVisitor.visit(dotstream,tasknodes);
  45                 } catch(Exception e) {
  46                     e.printStackTrace();
  47                     throw new Error();
  48                 }
  49             }
  50         }
  51     }
  52
  53     /** Returns the set of TaskNodes for the class descriptor cd */
  54
  55     public Set getTaskNodes(ClassDescriptor cd) {
  56         if (cdtonodes.containsKey(cd))
  57             return ((Hashtable)cdtonodes.get(cd)).keySet();
  58         else
  59             return null;
  60     }
  61
  62     private TaskNode canonicalizeTaskNode(Hashtable nodes, TaskNode node){
  63         if (nodes.containsKey(node))
  64             return (TaskNode)nodes.get(node);
  65         else{
  66             nodes.put(node,node);
  67             return (TaskNode)node;
  68         }
  69     }
  70
  71     private void produceTaskNodes(ClassDescriptor cd) {
  72         Set fsnodes=taskanalysis.getFlagStates(cd);
  73         if (fsnodes==null)
  74             return;
  75
  76         Hashtable<TaskNode,TaskNode> tasknodes=new Hashtable<TaskNode,TaskNode>();
  77         cdtonodes.put(cd, tasknodes);
  78
  79         for(Iterator it=fsnodes.iterator();it.hasNext();) {
  80             FlagState fs=(FlagState)it.next();
  81             Iterator it_inedges=fs.inedges();
  82             TaskNode tn,sn;
  83
  84                 if (fs.isSourceNode()) {
  85                         sn=new TaskNode("Start Node");
  86                         if(fs.edges().hasNext()){
  87                                  addEdges(fs,sn,tasknodes);
  88                         }
  89                 }
  90
  91                 while(it_inedges.hasNext()){
  92
  93                     FEdge inedge=(FEdge)it_inedges.next();
  94                     tn=new TaskNode(inedge.getLabel());
  95                     if(fs.edges().hasNext()){
  96                         addEdges(fs,tn,tasknodes);
  97                         }
  98             }
  99         }
 100     }
 101
 102     private void produceAllTaskNodes(){
 103             alltasknodes=new Hashtable<TaskNode,TaskNode>();
 104
 105             for(Iterator it_tasks=state.getTaskSymbolTable().getDescriptorsIterator();it_tasks.hasNext();){
 106                     TaskDescriptor td=(TaskDescriptor)it_tasks.next();
 107                     TaskNode tn=new TaskNode(td.getSymbol());
 108                     alltasknodes.put(tn,tn);
 109             }
 110             TaskNode tn_runtime=new TaskNode("Runtime");
 111             alltasknodes.put(tn_runtime,tn_runtime);
 112
 113             int ColorID=0;
 114             for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext()&&ColorID<10;) {
 115             ClassDescriptor cd=(ClassDescriptor) classit.next();
 116                 Set fsnodes;
 117
 118                 if (cd.hasFlags()&&((fsnodes=taskanalysis.getFlagStates(cd))!=null)){
 119                         System.out.println(cd.getSymbol());
 120                         for(Iterator it=fsnodes.iterator();it.hasNext();) {
 121                                 FlagState fs=(FlagState)it.next();
 122                                         Iterator it_inedges=fs.inedges();
 123                                     TaskNode tn,sn;
 124
 125
 126                                     if (fs.isSourceNode()){
 127                                             if(fs.edges().hasNext()){
 128                                                 Vector allocatingtasks=fs.getAllocatingTasks();
 129                                                     for(Iterator it_at=allocatingtasks.iterator();it_at.hasNext();){
 130                                                             tn=new TaskNode(((TaskDescriptor)it_at.next()).getSymbol());
 131                                                             addEdges(fs,tn,alltasknodes,ColorID);
 132                                                     }
 133                                             }
 134                                     }
 135
 136                                     while(it_inedges.hasNext()){
 137                                             FEdge inedge=(FEdge)it_inedges.next();
 138                                         tn=new TaskNode(inedge.getLabel());
 139                                                 if(fs.edges().hasNext()){
 140                                                 addEdges(fs,tn,alltasknodes,ColorID);
 141                                                 }
 142                                 }
 143                         }
 144                         ColorID++;
 145                         }
 146
 147                 }
 148         }
 149
 150         public Set getAllTaskNodes(){
 151                 return alltasknodes.keySet();
 152         }
 153
 154
 155
 156
 157
 158
 159
 160
 161   /*    private void mergeAllNodes(){
 162                 Hashtable alltasks=new Hashtable();
 163                 for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext();) {
 164                 ClassDescriptor cd=(ClassDescriptor) classit.next();
 165                         Set tnodes=((Hashtable)cdtonodes.get(cd)).keyset();
 166                         while (it_tnodes=tnodes.iterator();it_nodes.hasNext()){
 167                                 TaskNode tn=it_nodes.next();
 168                                 if (alltasks.containsKey(tn)){
 169                                         while(tn.
 170                                 }
 171                         }
 172
 173
 174
 175
 176     }
 177
 178          */
 179
 180     private void addEdges(FlagState fs, TaskNode tn,Hashtable<TaskNode,TaskNode> tasknodes){
 181
 182           //  Hashtable<TaskNode,TaskNode> tasknodes=(Hashtable<TaskNode,TaskNode>)cdtonodes.get(fs.getClassDescriptor());
 183             tn=(TaskNode)canonicalizeTaskNode(tasknodes, tn);
 184                 for (Iterator it_edges=fs.edges();it_edges.hasNext();){
 185                         TaskNode target=new TaskNode(((FEdge)it_edges.next()).getLabel());
 186                         target=(TaskNode)canonicalizeTaskNode(tasknodes,target);
 187
 188                         TEdge newedge=new TEdge(target);
 189                         if (! tn.edgeExists(newedge))
 190                                 tn.addEdge(newedge);
 191             }
 192
 193         }
 194
 195         private void addEdges(FlagState fs, TaskNode tn,Hashtable<TaskNode,TaskNode> tasknodes,int ColorID){
 196
 197                 tn=(TaskNode)canonicalizeTaskNode(tasknodes, tn);
 198                 for (Iterator it_edges=fs.edges();it_edges.hasNext();){
 199                         TaskNode target=new TaskNode(((FEdge)it_edges.next()).getLabel());
 200                         target=(TaskNode)canonicalizeTaskNode(tasknodes,target);
 201
 202                         TEdge newedge=new TEdge(target);
 203                         newedge.setDotNodeParameters("style=bold, color = "+colors[ColorID]);
 204                         if (! tn.edgeExists(newedge))
 205                                 tn.addEdge(newedge);
 206             }
 207
 208         }
 209
 210 }