Robust/src/Analysis/TaskStateAnalysis/ExecutionGraph.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 import Util.Edge;
  11
  12 public class ExecutionGraph {
  13     private TaskAnalysis taskanalysis;
  14     private State state;
  15     private Hashtable executiongraph;
  16     private HashSet marked;
  17     private HashSet processed;
  18
  19     public ExecutionGraph(State state, TaskAnalysis ta){
  20         this.taskanalysis=ta;
  21         this.state=state;
  22         this.executiongraph = new Hashtable();
  23         this.marked=new HashSet();
  24         this.processed=new HashSet();
  25     }
  26
  27     public Hashtable getExecutionGraph(){
  28         return executiongraph;
  29     }
  30
  31     public void createExecutionGraph() throws java.io.IOException {
  32         //Cycle through classes
  33         Enumeration e=taskanalysis.flagstates.keys();
  34
  35         while (e.hasMoreElements()) {
  36             ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
  37             HashSet<EGTaskNode> graph=exploreGraph(cdtemp);
  38             adapt(cdtemp,graph);
  39         }
  40         printDOTFile();
  41     }
  42
  43     private HashSet<EGTaskNode> exploreGraph(ClassDescriptor cd) {
  44         LinkedList<FlagState> fifo = new LinkedList<FlagState>();
  45         HashSet<EGTaskNode> nodes=new HashSet<EGTaskNode>();
  46         Hashtable<FEdge, EGTaskNode> map=new Hashtable<FEdge, EGTaskNode>();
  47
  48         // Go through nodes
  49         Iterator<FlagState> it = taskanalysis.getFlagStates(cd).iterator();
  50         while (it.hasNext()) {
  51             FlagState fs = it.next();
  52             if(fs.isSourceNode()) {
  53                 for (Iterator allocit = ((Vector)fs.getAllocatingTasks()).iterator(); allocit.hasNext();) {
  54                     TaskDescriptor alloctask=(TaskDescriptor)allocit.next();
  55                     EGTaskNode srcnode=new EGTaskNode(alloctask.getSymbol(),alloctask, fs);
  56                     nodes.add(srcnode);
  57                     srcnode.setSource();
  58                     for (Iterator edges = fs.edges(); edges.hasNext();){
  59                         FEdge edge = (FEdge)edges.next();
  60                         EGTaskNode targetnode=getNode(edge, map, nodes);
  61                         EGEdge newedge=new EGEdge(fs, targetnode);
  62                         srcnode.addEdge(newedge);
  63                     }
  64                 }
  65             }
  66             for(Iterator init=fs.inedges();init.hasNext();) {
  67                 FEdge inedge=(FEdge)init.next();
  68                 EGTaskNode srcnode=getNode(inedge, map, nodes);
  69                 for(Iterator outit=fs.edges();outit.hasNext();) {
  70                     FEdge outedge=(FEdge)outit.next();
  71                     EGTaskNode dstnode=getNode(outedge, map, nodes);
  72                     EGEdge newedge=new EGEdge(fs,dstnode);
  73                     srcnode.addEdge(newedge);
  74                 }
  75             }
  76
  77         }
  78         return nodes;
  79     }
  80
  81     private EGTaskNode getNode(FEdge fedge, Hashtable<FEdge, EGTaskNode> map, HashSet<EGTaskNode> nodes) {
  82         if (map.containsKey(fedge))
  83             return map.get(fedge);
  84         EGTaskNode egnode=new EGTaskNode(fedge.getLabel(), (FlagState) fedge.getSource(), fedge.getTask(), fedge.getIndex(), (FlagState) fedge.getTarget());
  85         map.put(fedge, egnode);
  86         nodes.add(egnode);
  87         return egnode;
  88     }
  89
  90     //put the graph into executiongraph
  91     private void adapt(ClassDescriptor cd, HashSet<EGTaskNode> nodes) {
  92         HashSet tasknodes = new HashSet();
  93         tasknodes.addAll(nodes);
  94         executiongraph.put(cd,tasknodes);
  95     }
  96
  97     //print the contain of graph
  98     private void test(Hashtable graph) {
  99         System.out.println("\nGraph contains :");
 100         Collection c = graph.values();
 101         for ( Iterator it = c.iterator(); it.hasNext();){
 102             EGTaskNode tn = (EGTaskNode)it.next();
 103             System.out.println(tn.getTextLabel()+" ID "+tn.getLabel()+" FS "+tn.getFSName());
 104         }
 105     }
 106
 107     //create dot files execution_classname_.dot
 108     private void printDOTFile()throws java.io.IOException {
 109         Enumeration e = executiongraph.keys();
 110         while (e.hasMoreElements()){
 111             createDOTFile((ClassDescriptor)e.nextElement());
 112         }
 113     }
 114
 115     private void createDOTFile(ClassDescriptor cd) throws java.io.IOException {
 116         Set s = (Set)executiongraph.get(cd);
 117         java.io.PrintWriter output;
 118         File dotfile_flagstates= new File("execution"+cd.getSymbol()+".dot");
 119         FileOutputStream dotstream=new FileOutputStream(dotfile_flagstates,false);
 120         output = new java.io.PrintWriter(dotstream, true);
 121         output.println("digraph dotvisitor {");
 122         output.println("\tnode [fontsize=10,height=\"0.1\", width=\"0.1\"];");
 123         output.println("\tedge [fontsize=6];");
 124         traverse(output, s);
 125         output.println("}\n");
 126     }
 127
 128     private void traverse(java.io.PrintWriter output, Set v) {
 129         EGTaskNode tn;
 130
 131         for(Iterator it1 = v.iterator(); it1.hasNext();){
 132             tn = (EGTaskNode)it1.next();
 133             output.println("\t"+tn.getLabel()+" [label=\""+tn.getTextLabel()+"\"");
 134             if (tn.isMultipleParams()) output.println(", color=blue");
 135             output.println("];");
 136
 137             for(Iterator it2 = tn.edges();it2.hasNext();){
 138                 output.println("\t"+tn.getLabel()+" -> "+((EGTaskNode)((EGEdge)it2.next()).getTarget()).getLabel()+";");
 139             }
 140         }
 141     }
 142 }