Robust/src/Analysis/Scheduling/TaskSimulator.java

   1 package Analysis.Scheduling;
   2
   3 import java.util.Hashtable;
   4 import java.util.Iterator;
   5 import java.util.LinkedList;
   6 import java.util.Queue;
   7 import java.util.Vector;
   8
   9 import Analysis.TaskStateAnalysis.FEdge;
  10 import Analysis.TaskStateAnalysis.FlagState;
  11 import Analysis.TaskStateAnalysis.FEdge.NewObjInfo;
  12 import IR.ClassDescriptor;
  13 import IR.TaskDescriptor;
  14 import IR.VarDescriptor;
  15 import IR.Tree.FlagExpressionNode;
  16
  17 public class TaskSimulator {
  18     TaskDescriptor td;
  19     Vector<Queue<ObjectSimulator>> paraQueues;
  20     Hashtable<ObjectSimulator, Integer> objVersionTbl;
  21     ExeResult currentRun;
  22     CoreSimulator cs;
  23     boolean finish;
  24
  25     public class ExeResult {
  26         int finishTime;
  27         Vector<ObjectSimulator> newObjs;
  28         int exetype; // 0--normal executing
  29                      // 1--abort due to fail on grabbing locks
  30                      // 2--out of date task
  31
  32         public ExeResult() {
  33             finishTime = 0;
  34             newObjs = null;
  35         }
  36
  37         public int getFinishTime() {
  38             return finishTime;
  39         }
  40
  41         public void setFinishTime(int finishTime) {
  42             this.finishTime = finishTime;
  43         }
  44
  45         public Vector<ObjectSimulator> getNewObjs() {
  46             return newObjs;
  47         }
  48
  49         public void addNewObj(ObjectSimulator newObj) {
  50             if(this.newObjs == null) {
  51                 this.newObjs = new Vector<ObjectSimulator>();
  52             }
  53
  54             this.newObjs.add(newObj);
  55         }
  56
  57         public int getExetype() {
  58             return exetype;
  59         }
  60
  61         public void setExetype(int exetype) {
  62             this.exetype = exetype;
  63         }
  64     }
  65
  66     public TaskSimulator(TaskDescriptor td, CoreSimulator cs) {
  67         super();
  68         this.td = td;
  69         this.paraQueues = null;
  70         this.objVersionTbl = null;
  71         this.currentRun = null;
  72         this.cs = cs;
  73         this.finish = true;
  74     }
  75
  76     public CoreSimulator getCs() {
  77         return cs;
  78     }
  79
  80     public TaskDescriptor getTd() {
  81         return td;
  82     }
  83
  84     public ExeResult getCurrentRun() {
  85         return currentRun;
  86     }
  87
  88     public Vector<Queue<ObjectSimulator>> getParaQueues() {
  89         return paraQueues;
  90     }
  91
  92     public Hashtable<ObjectSimulator, Integer> getObjVersionTbl() {
  93         return objVersionTbl;
  94     }
  95
  96     public int getObjVersion(ObjectSimulator os) {
  97         return this.objVersionTbl.get(os).intValue();
  98     }
  99
 100     public void enquePara(ObjectSimulator obj, FlagState fs, int version, boolean inherent) {
 101         ClassDescriptor cd = obj.getCd();
 102         int paraNum = td.numParameters();
 103         for(int i = 0; i < paraNum; i++) {
 104             VarDescriptor para = td.getParameter(i);
 105             if(cd.equals(para.getType().getClassDesc())) {
 106                 // check if the status is right
 107                 FlagExpressionNode fen = td.getFlag(para);
 108                 FlagState cfs = fs;
 109                 if(inherent) {
 110                     cfs = obj.getCurrentFS();
 111                 }
 112                 if(SchedulingUtil.isTaskTrigger_flag(fen, cfs)) {
 113                     if(this.paraQueues == null) {
 114                         this.paraQueues = new Vector<Queue<ObjectSimulator>>();
 115                         for(int j = 0; j < paraNum; j++) {
 116                             this.paraQueues.add(null);
 117                         }
 118                     }
 119                     if(this.paraQueues.elementAt(i) == null) {
 120                         this.paraQueues.setElementAt(new LinkedList<ObjectSimulator>(), i);
 121                     }
 122                     if(this.objVersionTbl == null) {
 123                         this.objVersionTbl = new Hashtable<ObjectSimulator, Integer>();
 124                     }
 125                     if(!this.paraQueues.elementAt(i).contains(obj)) {
 126                         this.paraQueues.elementAt(i).add(obj);
 127                         if(inherent) {
 128                             this.objVersionTbl.put(obj, obj.getVersion());
 129                         } else {
 130                             this.objVersionTbl.put(obj, version);
 131                         }
 132                     }
 133                 }
 134             }
 135         }
 136     }
 137
 138     public void refreshPara(ObjectSimulator obj, boolean remove) {
 139         ClassDescriptor cd = obj.getCd();
 140         int paraNum = td.numParameters();
 141         for(int i = 0; i < paraNum; i++) {
 142             VarDescriptor para = td.getParameter(i);
 143             if(cd.equals(para.getType().getClassDesc())) {
 144                 if(remove) {
 145                     if((this.paraQueues != null) &&
 146                             (this.paraQueues.elementAt(i) != null)  &&
 147                             (this.paraQueues.elementAt(i).contains(obj))) {
 148                         this.paraQueues.elementAt(i).remove(obj);
 149                         this.objVersionTbl.remove(obj);
 150                     }
 151                 } else {
 152                     // check if the status is right
 153                     FlagExpressionNode fen = td.getFlag(para);
 154                     if(SchedulingUtil.isTaskTrigger_flag(fen, obj.getCurrentFS())) {
 155                         if(this.paraQueues == null) {
 156                             this.paraQueues = new Vector<Queue<ObjectSimulator>>();
 157                             for(int j = 0; j < paraNum; j++) {
 158                                 this.paraQueues.add(null);
 159                             }
 160                         }
 161                         if(this.paraQueues.elementAt(i) == null) {
 162                             this.paraQueues.setElementAt(new LinkedList<ObjectSimulator>(), i);
 163                         }
 164                         this.paraQueues.elementAt(i).add(obj);
 165                         if(this.objVersionTbl == null) {
 166                             this.objVersionTbl = new Hashtable<ObjectSimulator, Integer>();
 167                         }
 168                         this.objVersionTbl.put(obj, obj.getVersion());
 169                     } else {
 170                         if((this.paraQueues != null) &&
 171                                 (this.paraQueues.elementAt(i) != null)  &&
 172                                 (this.paraQueues.elementAt(i).contains(obj))){
 173                             this.paraQueues.elementAt(i).remove(obj);
 174                             this.objVersionTbl.remove(obj);
 175                         }
 176                     }
 177                 }
 178             }
 179         }
 180     }
 181
 182     public void process() {
 183         if(!finish) {
 184             return;
 185         } else {
 186             finish = false;
 187         }
 188
 189         if(this.currentRun == null) {
 190             this.currentRun = new ExeResult();
 191         }
 192
 193         int finishTime = 0;
 194         // According to runtime statistic information, decide the execution path of this task this time.
 195         // Mainly following things:
 196         //    1.the result, i.e. the result FlagState reached by each parameter.
 197         //    2.the finish time
 198         //    3.any new objects
 199
 200         // First check if all the parameters are still available.
 201         // For shared objects, need to first grab the lock and also check if the version is right
 202         for(int i = 0; i < paraQueues.size(); i++) {
 203             ObjectSimulator tpara = paraQueues.elementAt(i).peek();
 204             if(tpara.isShared()) {
 205                 if(tpara.isHold()) {
 206                     // shared object held by other tasks
 207                     finishTime = 1; // TODO currenly assume the effort on requesting locks are only 1
 208                     this.currentRun.setFinishTime(finishTime);
 209                     this.currentRun.setExetype(1);
 210                     paraQueues.elementAt(i).poll();
 211                     paraQueues.elementAt(i).add(tpara);
 212                     for(int j = 0; j < i; ++j) {
 213                         tpara = this.paraQueues.elementAt(j).poll();
 214                         if(tpara.isShared() && tpara.isHold()) {
 215                             tpara.setHold(false);
 216                         }
 217                         this.paraQueues.elementAt(j).add(tpara);
 218                     }
 219                     return;
 220                 } else if (tpara.getVersion() != this.objVersionTbl.get(tpara)) {
 221                     // shared object has been updated and no longer fitted to this task
 222                     finishTime = 1; // TODO currenly assume the effort on requesting locks are only 1
 223                     this.currentRun.setFinishTime(finishTime);
 224                     this.currentRun.setExetype(2);
 225                     paraQueues.elementAt(i).poll();
 226                     // remove this object from the remaining parameter queues
 227                     for(int j = i + 1; j < paraQueues.size(); j++) {
 228                         paraQueues.elementAt(j).remove(tpara);
 229                     }
 230                     for(int j = 0; j < i; ++j) {
 231                         tpara = this.paraQueues.elementAt(j).poll();
 232                         if(tpara.isShared() && tpara.isHold()) {
 233                             tpara.setHold(false);
 234                         }
 235                         this.paraQueues.elementAt(j).add(tpara);
 236                     }
 237                     return;
 238                 } else {
 239                     tpara.setHold(true);
 240                 }
 241             }
 242             // remove this object from the remaining parameter queues
 243             for(int j = i + 1; j < paraQueues.size(); j++) {
 244                 paraQueues.elementAt(j).remove(tpara);
 245             }
 246         }
 247         for(int i = 0; i < paraQueues.size(); i++) {
 248             ObjectSimulator tpara = paraQueues.elementAt(i).peek();
 249
 250             FlagState tfstate = tpara.getCurrentFS();
 251             FEdge toexecute = tfstate.process(td);
 252             finishTime += toexecute.getExeTime();
 253             if((toexecute.getNewObjInfoHashtable() != null) && (toexecute.getNewObjInfoHashtable().size() > 0)) {
 254                 // have new objects
 255                 Iterator it = toexecute.getNewObjInfoHashtable().keySet().iterator();
 256                 int invokeNum = toexecute.getInvokeNum();
 257                 while(it.hasNext()) {
 258                     ClassDescriptor cd = (ClassDescriptor)it.next();
 259                     NewObjInfo noi = toexecute.getNewObjInfo(cd);
 260                     if(noi.getInvokeNum() < ((int)Math.round(((noi.getProbability() / 100) * noi.getNewRate() * invokeNum)))) {
 261                         for(int j = 0; j < noi.getNewRate(); j++) {
 262                             ObjectSimulator tmpObj = new ObjectSimulator(cd, noi.getRoot());
 263                             this.currentRun.addNewObj(tmpObj);
 264                             noi.incInvokeNum();
 265                         }
 266                     }
 267                 }
 268             }
 269             tpara.applyEdge(toexecute);
 270             tpara.increaseVersion();
 271         }
 272         finishTime /= paraQueues.size();
 273         this.currentRun.setFinishTime(finishTime);
 274         this.currentRun.setExetype(0);
 275     }
 276
 277     public void updateFinishTime(int time) {
 278         this.currentRun.setFinishTime(this.currentRun.finishTime - time);
 279         finish = false;
 280     }
 281
 282     public void finish() {
 283         this.finish = true;
 284     }
 285 }