Robust/src/Analysis/Scheduling/CoreSimulator.java

   1 package Analysis.Scheduling;
   2
   3 import java.util.Hashtable;
   4 import java.util.Queue;
   5 import java.util.Vector;
   6
   7 import Analysis.TaskStateAnalysis.FlagState;
   8 import IR.TaskDescriptor;
   9
  10 public class CoreSimulator {
  11     Vector<TaskSimulator> tasks;
  12     RuntimeSchedule rSchedule;
  13     TaskSimulator rtask;
  14     Hashtable<FlagState, Queue<Integer>> targetCSimulator;
  15     Hashtable<FlagState, Vector<Integer>> allyCSimulator;
  16     Hashtable<FlagState, FlagState> targetFState;
  17     int coreNum;
  18     int activeTime;
  19
  20     public CoreSimulator(RuntimeSchedule schedule, int coreNum) {
  21         super();
  22         reset();
  23         this.rSchedule = schedule;
  24         this.coreNum = coreNum;
  25     }
  26
  27     public CoreSimulator(int coreNum) {
  28         super();
  29         reset();
  30         this.coreNum = coreNum;
  31     }
  32
  33     public void reset() {
  34         this.activeTime = 0;
  35         this.tasks = null;
  36         this.targetCSimulator = null;
  37         this.targetFState = null;
  38         this.rSchedule = null;
  39         this.rtask = null;
  40     }
  41
  42     public void deployTasks(Vector<TaskDescriptor> tasks) {
  43         if(tasks == null) {
  44             return;
  45         }
  46
  47         if(this.tasks == null) {
  48             this.tasks = new Vector<TaskSimulator>();
  49         } else {
  50             this.tasks.clear();
  51         }
  52
  53         for(int i = 0; i < tasks.size(); i++) {
  54             TaskDescriptor td = tasks.elementAt(i);
  55             this.tasks.add(new TaskSimulator(td, this));
  56         }
  57     }
  58
  59     public Queue<Integer> getTargetCores(FlagState fstate) {
  60         if(targetCSimulator == null) {
  61             return null;
  62         }
  63         return targetCSimulator.get(fstate);
  64     }
  65
  66     public void setTargetCSimulator(Hashtable<FlagState, Queue<Integer>> targetCSimulator) {
  67         this.targetCSimulator = targetCSimulator;
  68     }
  69
  70     public Vector<Integer> getAllyCores(FlagState fstate) {
  71         if(allyCSimulator == null) {
  72             return null;
  73         }
  74         return allyCSimulator.get(fstate);
  75     }
  76
  77     public void setAllyCSimulator(Hashtable<FlagState, Vector<Integer>> allyCSimulator) {
  78         this.allyCSimulator = allyCSimulator;
  79     }
  80
  81     public FlagState getTargetFState(FlagState fstate) {
  82         if(targetFState == null) {
  83             return fstate;
  84         }
  85         return targetFState.get(fstate);
  86     }
  87
  88     public void setTargetFState(Hashtable<FlagState, FlagState> targetFState) {
  89         this.targetFState = targetFState;
  90     }
  91
  92     public int getActiveTime() {
  93         return activeTime;
  94     }
  95
  96     public int getCoreNum() {
  97         return coreNum;
  98     }
  99
 100     public Vector<TaskSimulator> getTasks() {
 101         return tasks;
 102     }
 103
 104     public RuntimeSchedule getRSchedule() {
 105         return rSchedule;
 106     }
 107
 108     public void setRSchedule(RuntimeSchedule schedule) {
 109         rSchedule = schedule;
 110     }
 111
 112     public TaskSimulator getRtask() {
 113         return rtask;
 114     }
 115
 116     public void addObject(ObjectSimulator newObj) {
 117         if(this.tasks == null) {
 118             return;
 119         }
 120         for(int i = 0; i < this.tasks.size(); i++) {
 121             this.tasks.elementAt(i).enquePara(newObj, null, 0, true);
 122         }
 123     }
 124
 125     public void addObject(ObjectSimulator newObj, FlagState fs, int version) {
 126         if(this.tasks == null) {
 127             return;
 128         }
 129         for(int i = 0; i < this.tasks.size(); i++) {
 130             this.tasks.elementAt(i).enquePara(newObj, fs, version, false);
 131         }
 132     }
 133
 134     public Vector<ObjectSimulator> finishTask() {
 135         assert(this.rtask != null);
 136
 137         Vector<ObjectSimulator> transObjs = null;
 138         Vector<Queue<ObjectSimulator>> paraQueues = this.rtask.getParaQueues();
 139         for(int i = 0; i < paraQueues.size(); i++) {
 140             ObjectSimulator obj = paraQueues.elementAt(i).poll();
 141             obj.setHold(false);
 142             boolean remove = false;
 143             if((this.targetFState != null) && (this.targetFState.containsKey(obj.getCurrentFS()))) {
 144                 if(transObjs == null) {
 145                     transObjs = new Vector<ObjectSimulator>();
 146                 }
 147                 if(!transObjs.contains(obj)) {
 148                     transObjs.add(obj);
 149                 }
 150                 remove = true;
 151             }
 152             // check if this object becoming shared or not
 153             Vector<Integer> allycores = this.getAllyCores(obj.getCurrentFS());
 154             if(allycores != null) {
 155                 obj.setShared(true);
 156                 for(int k = 0; k < allycores.size(); ++k) {
 157                     Integer allyCore = allycores.elementAt(k);
 158                     if(transObjs == null) {
 159                         transObjs = new Vector<ObjectSimulator>();
 160                     }
 161                     if(!transObjs.contains(obj)) {
 162                         transObjs.add(obj);
 163                     }
 164                     remove = false;
 165                 }
 166             }
 167             for(int j = 0; j < this.tasks.size(); j++) {
 168                 this.tasks.elementAt(j).refreshPara(obj, remove);
 169             }
 170         }
 171         this.activeTime += this.rtask.getCurrentRun().getFinishTime();
 172         this.rtask.finish();
 173         this.rtask = null;
 174         return transObjs;
 175     }
 176
 177     public void updateTask(int time) {
 178         this.activeTime += time;
 179         this.rtask.updateFinishTime(time);
 180     }
 181
 182     public TaskSimulator process() {
 183         TaskSimulator next = rSchedule.schedule(tasks);
 184         this.rtask = next;
 185         return next;
 186     }
 187
 188 }