start of new file

[IRC.git] / Robust / src / Analysis / TaskStateAnalysis / TaskGraph.java

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java b/Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java
index 00b31dc07259319366acba057e43b53fa44b8f49..7f05d280b3c9368595d7a66bf8c0faec69329df7 100644 (file)
--- a/Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java
+++ b/Robust/src/Analysis/TaskStateAnalysis/TaskGraph.java
@@ -3,6 +3,7 @@ import java.util.*;
 import IR.State;
 import IR.SymbolTable;
 import IR.ClassDescriptor;
+import IR.TaskDescriptor;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.FileOutputStream;
@@ -11,17 +12,24 @@ public class TaskGraph {
     TaskAnalysis taskanalysis;
     State state;
     Hashtable cdtonodes;
+    Hashtable nodes;
+    Hashtable<TaskNode,TaskNode> alltasknodes;
+    
+    //Colors
+    String colors[]={"red","blue","green","brown","orange","pink","black","grey","olivedrab","yellow"};
 
     public TaskGraph(State state, TaskAnalysis taskanalysis) {
        this.state=state;
        this.taskanalysis=taskanalysis;
        this.cdtonodes=new Hashtable();
+       this.alltasknodes=new Hashtable<TaskNode,TaskNode>();
 
        for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext();) {
            ClassDescriptor cd=(ClassDescriptor) classit.next();
            if (cd.hasFlags())
                produceTaskNodes(cd);
        }
+       produceAllTaskNodes();
     }
     
     
@@ -74,10 +82,14 @@ public class TaskGraph {
            TaskNode tn,sn;
           
                if (fs.isSourceNode()) {
-                       sn=new TaskNode("Start Node");
+                   Vector src=fs.getAllocatingTasks();
+                   for(Iterator it2=src.iterator();it2.hasNext();) {
+                       TaskDescriptor td=(TaskDescriptor)it2.next();
+                       sn=new TaskNode(td.getSymbol());
                        if(fs.edges().hasNext()){
-                                addEdges(fs,sn);
+                                addEdges(fs,sn,tasknodes);
                        }       
+                   }
                }
                                                
                while(it_inedges.hasNext()){   
@@ -85,15 +97,110 @@ public class TaskGraph {
                    FEdge inedge=(FEdge)it_inedges.next();
                    tn=new TaskNode(inedge.getLabel());
                    if(fs.edges().hasNext()){
-                       addEdges(fs,tn);
+                       addEdges(fs,tn,tasknodes);
                        }
            }  
        }
     }
     
-    private void addEdges(FlagState fs, TaskNode tn){
+    private void produceAllTaskNodes(){
+           alltasknodes=new Hashtable<TaskNode,TaskNode>();
+           
+           for(Iterator it_tasks=state.getTaskSymbolTable().getDescriptorsIterator();it_tasks.hasNext();){
+                   TaskDescriptor td=(TaskDescriptor)it_tasks.next();
+                   TaskNode tn=new TaskNode(td.getSymbol());
+                   alltasknodes.put(tn,tn);
+           }
+           TaskNode tn_runtime=new TaskNode("Runtime");
+           alltasknodes.put(tn_runtime,tn_runtime);
+           
+           int ColorID=0;
+           for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext()&&ColorID<10;) {
+           ClassDescriptor cd=(ClassDescriptor) classit.next();
+               Set fsnodes;
+               
+               if (cd.hasFlags()&&((fsnodes=taskanalysis.getFlagStates(cd))!=null)){
+                       //
+                       System.out.println("\nWorking on fses of Class: "+cd.getSymbol());
+                       //
+                       for(Iterator it=fsnodes.iterator();it.hasNext();) {
+                               FlagState fs=(FlagState)it.next();
+                               //
+                               System.out.println("Evaluating fs: "+fs.getTextLabel());
+                               //
+                                       Iterator it_inedges=fs.inedges();       
+                                   TaskNode tn,sn;
+                                   
+                                   
+                                   if (fs.isSourceNode()){
+                                           //
+                                           System.out.println("A sourcenode");
+                                           //
+                                           if(fs.edges().hasNext()){
+                                               Vector allocatingtasks=fs.getAllocatingTasks();
+                                               //
+                                               if (allocatingtasks.iterator().hasNext())
+                                                       System.out.println("has been allocated by "+allocatingtasks.size()+" tasks");
+                                               //
+                                                   for(Iterator it_at=allocatingtasks.iterator();it_at.hasNext();){
+                                                           TaskDescriptor allocatingtd=(TaskDescriptor)it_at.next();
+                                                           //
+                                                           System.out.println(allocatingtd.getSymbol());
+                                                           //
+                                                           tn=new TaskNode(allocatingtd.getSymbol());
+                                                           
+                                                           addEdges(fs,tn,alltasknodes,ColorID);
+                                                   }
+                                           }
+                                   }
+                                   
+                                   while(it_inedges.hasNext()){   
+                                           FEdge inedge=(FEdge)it_inedges.next();
+                                       tn=new TaskNode(inedge.getLabel());
+                                               if(fs.edges().hasNext()){
+                                               addEdges(fs,tn,alltasknodes,ColorID);
+                                               }
+                               }
+                       }
+                       ColorID++;
+                       }
+                       
+               }
+       }  
+       
+       public Set getAllTaskNodes(){
+               return alltasknodes.keySet();
+       }
+                                   
+                                                   
+                   
+                   
+               
+       
+           
+    
+  /*   private void mergeAllNodes(){
+               Hashtable alltasks=new Hashtable();
+               for(Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();classit.hasNext();) {
+               ClassDescriptor cd=(ClassDescriptor) classit.next();
+                       Set tnodes=((Hashtable)cdtonodes.get(cd)).keyset();
+                       while (it_tnodes=tnodes.iterator();it_nodes.hasNext()){
+                               TaskNode tn=it_nodes.next();
+                               if (alltasks.containsKey(tn)){
+                                       while(tn.
+                               }
+                       }
+                       
+           
+           
+           
+    }
+    
+        */   
+    
+    private void addEdges(FlagState fs, TaskNode tn,Hashtable<TaskNode,TaskNode> tasknodes){
            
-           Hashtable<TaskNode,TaskNode> tasknodes=(Hashtable<TaskNode,TaskNode>)cdtonodes.get(fs.getClassDescriptor());
+         //  Hashtable<TaskNode,TaskNode> tasknodes=(Hashtable<TaskNode,TaskNode>)cdtonodes.get(fs.getClassDescriptor());
            tn=(TaskNode)canonicalizeTaskNode(tasknodes, tn);
                for (Iterator it_edges=fs.edges();it_edges.hasNext();){
                        TaskNode target=new TaskNode(((FEdge)it_edges.next()).getLabel());
@@ -101,8 +208,24 @@ public class TaskGraph {
 
                        TEdge newedge=new TEdge(target);
                        if (! tn.edgeExists(newedge))
-                               tn.addEdge(new TEdge(target));
+                               tn.addEdge(newedge);
+           }
+
+       }
+       
+       private void addEdges(FlagState fs, TaskNode tn,Hashtable<TaskNode,TaskNode> tasknodes,int ColorID){
+               
+               tn=(TaskNode)canonicalizeTaskNode(tasknodes, tn);
+               for (Iterator it_edges=fs.edges();it_edges.hasNext();){
+                       TaskNode target=new TaskNode(((FEdge)it_edges.next()).getLabel());
+                       target=(TaskNode)canonicalizeTaskNode(tasknodes,target);
+
+                       TEdge newedge=new TEdge(target);
+                       newedge.setDotNodeParameters("style=bold, color = "+colors[ColorID]);
+                       if (! tn.edgeExists(newedge))
+                               tn.addEdge(newedge);
            }
 
        }
+       
 }