GreenCloud Simulator
corescheduler.cc
Go to the documentation of this file.
1 /*
2  * corescheduler.cc
3  *
4  * @date Aug 29, 2013
5  * @author Guzek:Mateusz
6  */
7 
8 #include "corescheduler.h"
9 #include "cloudtask.h"
10 #include "resourceprovider.h"
11 
12 CoreScheduler::CoreScheduler(Capacity * nominal_mips_,Capacity * available_mips_) : current_mips_(0.0), host_scheduler_(NULL), tskAllocFailed_(0) {
13  this->nominal_mips_=nominal_mips_;
14  this->available_mips_=available_mips_;
15  tasks_alloc_list_.clear();
16  tasks_alloc_assigned_.clear();
18 
19 }
20 
21 
22 
24  std::vector <TaskAlloc*>::iterator task;
25  for(task = tasks_alloc_list_.begin(); task!=tasks_alloc_list_.end() ;task++){
26  delete (*task);
27  }
28  tasks_alloc_list_.~vector();
29  for(task = tasks_alloc_assigned_.begin(); task!=tasks_alloc_assigned_.end() ;task++){
30  delete (*task);
31  }
32  tasks_alloc_assigned_.~vector();
33 }
34 
36  this->provider = provider;
37 }
38 
40  this->eDVFS_enabled_ = eDVFS_enabled_;
41 }
42 
44  return current_mips_;
45 }
47  double result = getCurrentMIPS();
48  std::vector<CoreScheduler*>::iterator iter;
49  int i = 1;
50  for(iter = hosted_vcores_schedulers.begin(); iter != hosted_vcores_schedulers.end();iter++){
51  result += (*iter)->getCurrentMIPSRecursive();
52  i++;
53  }
54  return result;
55 }
57  return *nominal_mips_;
58 }
60  return *available_mips_;
61 }
62 
64  return provider;
65 }
66 
68  return tasks_alloc_list_.size() + tasks_alloc_assigned_.size();
69 }
70 
72  tasks_alloc_assigned_.push_back(tskobj);
73  tskobj->setCoreScheduler(this);
74 }
75 
77  tasks_alloc_list_.push_back(tskobj); // add to the active tasks links
78  tskobj->setCoreScheduler(this);
79 }
80 
82  vector<TaskAlloc*>::iterator iter;
83  for (iter = tasks_alloc_assigned_.begin(); iter != tasks_alloc_assigned_.end();iter++)
84  {
85  /* task received remove from in-fly list */
86  if ((*iter) == tskobj) {
87  tasks_alloc_assigned_.erase(iter);
88  return true;
89  }
90  }
91  return false;
92 }
93 
95  vector<TaskAlloc*>::iterator iter;
96  bool found = false;
97  for (iter = tasks_alloc_assigned_.begin(); iter != tasks_alloc_assigned_.end();)
98  {
99  /* task received remove from in-fly list */
100  if ((*iter)->cloudTask->id_ == tskobj->id_) {
101  iter = tasks_alloc_assigned_.erase(iter);
102  found = true;
103  } else {
104  iter++;
105  }
106  }
107  return found;
108 }
109 
111  vector<TaskAlloc*>::iterator iter;
112  for (iter = tasks_alloc_assigned_.begin(); iter != tasks_alloc_assigned_.end();)
113  {
114  /* task received remove from in-fly list */
115  if ((*iter)->cloudTask->id_ == tskobj->id_) {
116  executeTask((*iter));
117  (*iter)->setExecTime(Scheduler::instance().clock());
118  iter = tasks_alloc_assigned_.erase(iter);
119 
120  } else {
121  iter++;
122  }
123  }
124  if(!tskobj->started_){
125  tskobj->started_ = true;
126  }
127  this->updateTskList();
128 }
129 
130 
131 CloudTask* CoreScheduler::removeTaskAlloc( vector<TaskAlloc*>::iterator& iter,bool executed)
132 {
133  CloudTask* result = (*iter)->cloudTask;
135 
136  (*iter)->cloudTask->removeTaskAlloc(*iter);
137  if(executed){
138  iter = tasks_alloc_list_.erase(iter);
139  }
140  else {
141  //The tasks that fails while being on assigned list
142  //was never executed, so cannot finish successfully
143  iter = tasks_alloc_assigned_.erase(iter);
144  }
145  return result;
146 }
147 
149 {
151  tskAllocFailed_++;
152  tasks_alloc_list_.erase(remove(tasks_alloc_list_.begin(),tasks_alloc_list_.end(),ta),
153  tasks_alloc_list_.end()); /*erase-remove idiom*/
155  tasks_alloc_assigned_.end()); /*erase-remove idiom*/
156 }
157 
158 void CoreScheduler::removeFailedTaskAlloc(vector<TaskAlloc*>::iterator& iter,bool executed)
159 {
160  if((*iter)->cloudTask->failed_==false){
161  (*iter)->cloudTask->fail(this->provider);
162  }
163  // REMOVE ALL TASK ALLOCATIONS FOR THE CLOUDTASK OF THIS TASK_ALLOC
164  if(executed){
165  iter = tasks_alloc_list_.begin();
166  } else {
167  iter = tasks_alloc_assigned_.begin();
168  }
169 }
170 
171 
172 // TODO the deadline check should happen before removal of the completed tasks!
174 {
175  std::vector<TaskAlloc*>::iterator iter;
176 
177  /* remove completed tasks from the execution list */
178  for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end();)
179  {
180  /* task should be completed and remove it from the list */
181  if ((*iter)->getMIPS() <= 1) {
182  CloudTask* ct = removeTaskAlloc(iter,true);
183  //check if finished:
184  if(ct->isFinished()){
187  }
188  }
189  /*Task run over its deadline, remove it and mark as failed. */
190  else if(Scheduler::instance().clock() >= (*iter)->cloudTask->getDeadline()) {
191  removeFailedTaskAlloc(iter,true);
192  } else if ((*iter)->cloudTask->failed_==true){
193  std::cerr << "This should not happen!\n";
194  }
195  else {
196  iter++;
197  }
198  }
199 }
200 
202 {
203  std::vector<TaskAlloc*>::iterator iter;
204 
205  /* update what is already computing */
206 
207  for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end(); iter++)
208  {
209  (*iter)->updateMIPS(); // update what is already computing
210  }
211  /* remove completed */
212  removeCompleted();
213 
214  /* Compute highest MIPS/deadline ratio */
215  double maxrate = 0.0;
216 
217  /* get most urgent task rate from the execution list */
218  for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end();)
219  {
220  if((double)((*iter)->getDeadline() - Scheduler::instance().clock())>0 && (*iter)->cloudTask->failed_==false){
221  double rate = (double)(*iter)->getMIPS()/(double)((*iter)->getDeadline() - Scheduler::instance().clock());
222  if(rate>maxrate){
223  maxrate = rate;
224  }
225  iter++;
226  }
227  else {
228  removeFailedTaskAlloc(iter,true);
229  }
230  }
231 
232  /* get most urgent task rate from the in-fly list */
233  for (iter = tasks_alloc_assigned_.begin(); iter != tasks_alloc_assigned_.end();)
234  {
235  if((double)((*iter)->getDeadline() - Scheduler::instance().clock())>0 && (*iter)->cloudTask->failed_==false){
236  double rate = (double)(*iter)->getMIPS()/(double)((*iter)->getDeadline() - Scheduler::instance().clock());
237  if(rate>maxrate){
238  maxrate = rate;
239  }
240  iter++;
241  } else {
242  removeFailedTaskAlloc(iter,false);
243  }
244  }
245  if (maxrate > getAvailableMIPS()){return getAvailableMIPS();}
246  else{return maxrate;}
247 }
248 
249 
250 
252 {
253  vector<TaskAlloc*>::iterator iter;
254 
255 
256  for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end(); iter++)
257  {
258  /* each task with then update mips left */
259  (*iter)->setComputingRate((double)c_mips/tasks_alloc_list_.size());
260  }
261 }
262 
263 void CoreScheduler::updateTskList(double c_mips)
264 {
265 
266  vector<TaskAlloc*>::iterator iter;
267  if (tasks_alloc_list_.size()==0) return;
268 // std::cout << "Prov: " << provider->id_ << "\n";
269  /* update task computing rates to see which tasks are completed */
270  updateTskComputingRates(c_mips);
271  removeCompleted();
272 
273  /* set server computing rate */
275 
276  /* compute next deadline */
277  double nextDeadline = DBL_MAX;
278  for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end(); iter++)
279  {
280  if (nextDeadline > (*iter)->execTime()){
281  nextDeadline = (*iter)->execTime();
282  }
283  }
284 
285 
286  provider->scheduleNextExent(nextDeadline);
287 
288 }
289 
292 }
293 
295 {
296  if (eDVFS_enabled_) {
297  /* Max requested rate times the number of active taks */
299  } else {
300  /* no energy saving */
301  if (tasks_alloc_list_.size() != 0){current_mips_ = getAvailableMIPS();}
302  else {(current_mips_) = 0;}
303  }
304  /* new computing rate, report it to tasks */
306 }
307 
309  hosted_vcores_schedulers.push_back(cs);
310  cs->host_scheduler_ = this;
311 }
312 
315  hosted_vcores_schedulers.end()); /*erase-remove idiom*/
316  cs->host_scheduler_ = NULL;
317 }
318 
320  return host_scheduler_;
321 }
322 
std::vector< TaskAlloc * > tasks_alloc_list_
Definition: corescheduler.h:69
CoreScheduler * getHostScheduler()
void setComputingRate()
void scheduleNextExent(double nextDeadline)
Capacity * available_mips_
Definition: corescheduler.h:64
CoreScheduler(Capacity *nominal_mips_, Capacity *available_mips_)
void sendTaskOutput(CloudTask *task)
ResourceProvider * getProvider()
std::vector< TaskAlloc * > tasks_alloc_assigned_
Definition: corescheduler.h:70
void startTaskExecution(CloudTask *tskobj)
CoreScheduler * host_scheduler_
Definition: corescheduler.h:71
double getMostUrgentTaskRate()
bool isFinished()
Definition: cloudtask.cc:83
int getAllTasksNumber()
void updateTskComputingRates(double c_mips)
double getNominalMIPS()
void setCoreScheduler(CoreScheduler *cs)
Definition: taskalloc.cc:28
int id_
Definition: cloudtask.h:51
double getAvailableMIPS()
void setDVFS(int eDVFS_enabled_)
bool removeAllocationsFromAssginedList(CloudTask *tskobj)
double current_mips_
Definition: corescheduler.h:65
virtual ~CoreScheduler()
CloudTask * removeTaskAlloc(std::vector< TaskAlloc * >::iterator &iter, bool executed)
void updateTskList()
void removeVcoreScheduler(CoreScheduler *cs)
void assignTask(TaskAlloc *tskobj)
double getCurrentMIPS()
Capacity * nominal_mips_
Definition: corescheduler.h:63
void removeFailedTaskAlloc(std::vector< TaskAlloc * >::iterator &iter, bool executed)
bool releaseAllocation(ResourceConsumer *rc)
virtual void updateEnergyAndConsumption()=0
double getCurrentMIPSRecursive()
void removeCompleted()
void addVcoreScheduler(CoreScheduler *cs)
void executeTask(TaskAlloc *tskobj)
bool removeFromAssginedList(TaskAlloc *tskobj)
ResourceProvider * provider
Definition: corescheduler.h:67
std::vector< CoreScheduler * > hosted_vcores_schedulers
Definition: corescheduler.h:68
void setProvider(ResourceProvider *provider)
bool started_
Definition: cloudtask.h:53