Robust/src/Analysis/TaskStateAnalysis/TaskTagAnalysis.java

   1 package Analysis.TaskStateAnalysis;
   2 import IR.*;
   3 import IR.Tree.*;
   4 import IR.Flat.*;
   5 import java.util.*;
   6 import java.io.File;
   7 import java.io.FileWriter;
   8 import java.io.FileOutputStream;
   9
  10 public class TaskTagAnalysis {
  11     State state;
  12     TagAnalysis taganalysis;
  13     TypeUtil typeutil;
  14     FlagInfo flaginfo;
  15     HashSet<TagState> toprocess;
  16     Hashtable<TaskDescriptor, TaskQueue> tasktable;
  17
  18
  19     /**
  20      * Class Constructor
  21      *
  22      */
  23     public TaskTagAnalysis(State state, TagAnalysis taganalysis) {
  24         this.state=state;
  25         this.typeutil=new TypeUtil(state);
  26         this.taganalysis=taganalysis;
  27         this.flaginfo=new FlagInfo(state);
  28         this.toprocess=new HashSet<TagState>();
  29         this.tasktable=new Hashtable<TaskDescriptor, TaskQueue>();
  30         for(Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();taskit.hasNext();) {
  31             TaskDescriptor td=(TaskDescriptor)taskit.next();
  32             tasktable.put(td, new TaskQueue(td));
  33         }
  34     }
  35
  36     private void doAnalysis() {
  37         toprocess.add(createInitialState());
  38
  39         while(!toprocess.isEmpty()) {
  40             TagState ts=toprocess.iterator().next();
  41             toprocess.remove(ts);
  42             //Loop through each task
  43             for(Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();taskit.hasNext();) {
  44                 TaskDescriptor td=(TaskDescriptor)taskit.next();
  45                 TaskQueue tq=tasktable.get(td);
  46                 processTask(td, tq, ts);
  47             }
  48         }
  49     }
  50
  51     private void processTask(TaskDescriptor td, TaskQueue tq, TagState ts) {
  52         Set<FlagState> flagset=ts.getFS();
  53         for(Iterator<FlagState> fsit=flagset.iterator();fsit.hasNext();) {
  54             FlagState fs=fsit.next();
  55             FlagTagState fts=new FlagTagState(ts, fs);
  56             for(int i=0;i<td.numParameters();i++) {
  57                 if (canEnqueue(td, i, fs)) {
  58                     TaskQueueIterator tqi=tq.enqueue(i, fts);
  59                     while(tqi.hasNext()) {
  60                         processBinding(tqi);
  61                         tqi.next();
  62                     }
  63                 }
  64             }
  65         }
  66     }
  67
  68     private void processBinding(TaskQueueIterator tqi) {
  69         TaskBinding tb=new TaskBinding(tqi);
  70         while(tb.hasNext()) {
  71             doAnalysis(tb);
  72
  73             tb.next();
  74         }
  75     }
  76
  77     private Hashtable<TempDescriptor, TagWrapper> computeInitialState(Hashtable<FlatNode, Hashtable<TempDescriptor, TagWrapper>> table, FlatNode fn) {
  78         Hashtable<TempDescriptor, TagWrapper> table=new Hashtable<TempDescriptor, TagWrapper>();
  79         for(int i=0;i<fn.numPrev();i++) {
  80             FlatNode fnprev=fn.getPrev(i);
  81             Hashtable<TempDescriptor, TagWrapper> prevtable=table.get(fn);
  82             for(Iterator<TempDescriptor> tmpit=prevtable.keySet().iterator();tmpit.hasNext();) {
  83                 TempDescriptor tmp=tmpit.next();
  84                 TagWrapper prevtag=prevtable.get(tmp);
  85                 if (table.containsKey(tmp)) {
  86                     TagWrapper currtag=table.get(tmp);
  87                 } else {
  88                     table.put(tmp, prevtag.clone());
  89                 }
  90
  91             }
  92         }
  93
  94         return table;
  95     }
  96
  97     private void doAnalysis(TaskBinding tb) {
  98         TaskDescriptor td=tb.tqi.tq.getTask();
  99         FlatMethod fm=state.getMethodFlat(td);
 100         Hashtable<FlatNode, Hashtable<TempDescriptor, TagWrapper>> table=new Hashtable<FlatNode, Hashtable<TempDescriptor, TagWrapper>>();
 101         table.put(fm, buildinittable(tb));
 102         HashSet<FlatNode> visited=new HashSet<FlatNode>();
 103         HashSet<FlatNode> tovisit=new HashSet<FlatNode>();
 104         tovisit.add(fm.getNext(0));
 105         while(!tovisit.isEmpty()) {
 106             FlatNode fn=tovisit.iterator().next();
 107             tovisit.remove(fn);
 108             visited.add(fn);
 109
 110
 111             for(int i=0;i<fn.numNext();i++) {
 112                 if (!visited.contains(fn.getNext(i)))
 113                     tovisit.add(fn.getNext(i));
 114             }
 115         }
 116
 117     }
 118
 119     private Hashtable<TempDescriptor, Set<TagWrapper>> buildinittable(TaskBinding tb) {
 120         Hashtable<TempDescriptor, Set<TagWrapper>> table=new Hashtable<TempDescriptor, Set<TagWrapper>>();
 121         Vector<TempDescriptor> tagtmps=tb.tqi.tq.tags;
 122         for(int i=0;i<tagtmps.size();i++) {
 123             TempDescriptor tmp=tagtmps.get(i);
 124             HashSet<TagWrapper> tset=new HashSet<TagWrapper>();
 125             tset.add(tb.getTag(tmp));
 126             table.put(tmp, tset);
 127         }
 128         return table;
 129     }
 130
 131     /*
 132       method summary:
 133       new flag states created
 134       new tag states created
 135       flag states bound to tag parameters
 136     */
 137
 138     public boolean canEnqueue(TaskDescriptor td, int paramnum, FlagState fs) {
 139         return typeutil.isSuperorType(td.getParamType(paramnum).getClassDesc(),fs.getClassDescriptor())&&
 140             isTaskTrigger_flag(td.getFlag(td.getParameter(paramnum)),fs)&&
 141             isTaskTrigger_tag(td.getTag(td.getParameter(paramnum)),fs);
 142     }
 143
 144     private static boolean isTaskTrigger_flag(FlagExpressionNode fen, FlagState fs) {
 145         if (fen==null)
 146             return true;
 147         else if (fen instanceof FlagNode)
 148             return fs.get(((FlagNode)fen).getFlag());
 149         else
 150             switch (((FlagOpNode)fen).getOp().getOp()) {
 151             case Operation.LOGIC_AND:
 152                 return ((isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs)) && (isTaskTrigger_flag(((FlagOpNode)fen).getRight(),fs)));
 153             case Operation.LOGIC_OR:
 154                 return ((isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs)) || (isTaskTrigger_flag(((FlagOpNode)fen).getRight(),fs)));
 155             case Operation.LOGIC_NOT:
 156                 return !(isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs));
 157             default:
 158                 return false;
 159             }
 160     }
 161
 162
 163     private static boolean isTaskTrigger_tag(TagExpressionList tel, FlagState fs){
 164         if (tel!=null){
 165             for (int i=0;i<tel.numTags() ; i++){
 166                 switch (fs.getTagCount(tel.getType(i))){
 167                 case FlagState.ONETAG:
 168                 case FlagState.MULTITAGS:
 169                     break;
 170                 case FlagState.NOTAGS:
 171                     return false;
 172                 }
 173             }
 174         }
 175         return true;
 176     }
 177
 178     TagState createInitialState() {
 179         ClassDescriptor startupobject=typeutil.getClass(TypeUtil.StartupClass);
 180         FlagDescriptor fd=(FlagDescriptor)startupobject.getFlagTable().get(FlagDescriptor.InitialFlag);
 181         FlagState fsstartup=(new FlagState(startupobject)).setFlag(fd,true);
 182         fsstartup.setAsSourceNode();
 183         fsstartup=canonical(fsstartup);
 184         TagState ts=new TagState();
 185         TagState[] tsarray=ts.addFS(fsstartup);
 186         return canonical(tsarray[0]);
 187     }
 188
 189     FlagState canonical(FlagState fs) {
 190         return fs;
 191     }
 192
 193     TagState canonical(TagState ts) {
 194         return ts;
 195     }
 196
 197
 198 }
 199