GreenCloud Simulator
datacenter.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
2 /*
3  */
4 
5 #ifndef lint
6 static const char rcsid[] =
7  "@(#) $Header: /cvsroot/nsnam/ns-2/common/datacenter.cc,v 1.43 $";
8 #endif
9 
10 #include <stdlib.h>
11 #include "datacenter.h"
12 #include "cloudtask.h"
13 
14 static class DataCenterClass : public TclClass {
15 public:
16  DataCenterClass() : TclClass("DataCenter") {}
17  TclObject* create(int argc, const char*const*argv) {
18  return (new DataCenter());
19  }
21 
22 DataCenter::DataCenter() : tskSubmitted_ (0),tskFailed_ (0), avgLoad_(0.0), avgLoadMem_(0.0),avgLoadStor_(0.0), avgPower_(0.0), dcScheduler(NULL), numHostTskAgents_(0), numVmTskAgents_(0),scheduleOnVms_(false)
23 
24 {
25  bind("tskSubmitted_", &tskSubmitted_);
26  bind("avgLoad_", &avgLoad_);
27  bind("avgLoadMem_", &avgLoadMem_);
28  bind("avgLoadStor_", &avgLoadStor_);
29  bind("avgPower_", &avgPower_);
30  bind("tskFailed_", &tskFailed_);
31 // dcScheduler = new GreenScheduler();
32 }
33 
34 
36 {
37  clear();
38 }
39 
41 
42  //TODO: this is the stub of the function, it should be finished to fully clear a DataCenter object.
43  host_list.clear();
44  host_agent_list.clear();
45  vector <ResourceSpec*>::iterator rs;
46  for(rs = resource_specification_list.begin();rs!= resource_specification_list.end(); rs++){
47  delete (* rs);
48  }
50  vector <ResourceProvider*>::iterator iter;
51  for(iter = host_list.begin();iter!= host_list.end(); iter++){
52  delete (* iter);
53  }
54  for(iter = vm_list.begin();iter!= vm_list.end(); iter++){
55  delete (* iter);
56  }
57  host_list.clear();
58  vm_list.clear();
59 }
60 
61 void DataCenter::setVmScheduling(bool scheduleOnVms){
62  this->scheduleOnVms_ = scheduleOnVms;
63 }
64 
66 {
67  host_list.push_back(newhst);
68 }
69 
71  vm_list.push_back(newvm);
72 }
73 
75 {
76  newagnt->set_pkttype(PT_CLOUD_USER);
77  host_agent_list.push_back(newagnt);
78 }
79 
81 {
82  newagnt->set_pkttype(PT_CLOUD_USER);
83  vm_agent_list.push_back(newagnt);
84 }
85 
87 {
88  resource_specification_list.push_back(newresspec);
89 }
90 
92  power_model_list.push_back(newPModel);
93 }
94 
95 
97 {
98  virt_resource_specification_list.push_back(newresspec);
99 }
100 
102 {
103  char output[100];
104  // Create the output for the Tcl interpreter.
105  sprintf(output, "puts \"Configuring VMs...\"");
106  Tcl& tcl = Tcl::instance();
107  tcl.eval(output);
108  return 0;
109 }
110 
111 int DataCenter::setScheduler(const char * scheduler_name){
112  if(dcScheduler!=NULL){
113  delete dcScheduler;
114  }
115  std::cout << "Selected DC scheduler: " << scheduler_name << "\n";
116  if(strcmp(scheduler_name, "Green") == 0){
117  dcScheduler = new GreenScheduler();
118  return 1;
119  } else if(strcmp(scheduler_name, "RoundRobin") == 0){
121  return 1;
122  } else if(strcmp(scheduler_name, "Random") == 0){
124  return 1;
125  } else if(strcmp(scheduler_name, "RandDENS") == 0){
126  dcScheduler = new RandDENS();
127  return 1;
128  } else if(strcmp(scheduler_name, "BestDENS") == 0){
129  dcScheduler = new BestDENS();
130  return 1;
131  } else if(strcmp(scheduler_name, "HEROS") == 0){
132  dcScheduler = new HerosScheduler();
133  return 1;
134  }
135 
136 
137  std::cerr << "Unknown scheduler type: " << scheduler_name;
138  abort();
139 
140 }
141 
143  // Create and allocate VmMigration object
144  Tcl& tcl = Tcl::instance();
145  tcl.evalf("set vmmigration_($next_migration_id) [new VmMigration]");
146  tcl.evalf("$vmmigration_($next_migration_id) set-id $next_migration_id");
147  tcl.evalf(
148  "$DCenter get-newest-migration $vmmigration_($next_migration_id)");
149 }
150 
152  createNewMigration(); // Creates and sets new migrations as tmp_migration_
154 
156  // The finalization of migration will be done by the migration object.
157  // The data center (probably) does not need to be informed about that, as the vm agent will be re-attached to the new location.
158  tmp_migration_ = NULL;
159 }
160 
161 void DataCenter::receivedTsk(int tsksize, CloudTask * pTask, const char* flags)
162 {
163  /* Update Stats */
164  tskSubmitted_ ++;
165 
166  /* Schedule it */
167  TskComAgent *tagent_ ;
168  if(scheduleOnVms_)// You can switch to another scheduler or providers list using this variable.
169  {
170  tagent_ = dcScheduler->scheduleTask((CloudTask *) pTask,vm_list); }
171  else {
172  tagent_ = dcScheduler->scheduleTask((CloudTask *) pTask,host_list);
173  }
174  if(tagent_==NULL){
175  tskFailed_++;
176  } else {
177  tagent_->sendmsg(tsksize, pTask, flags);
178  }
179 }
180 
182 {
184 
185  return (host_agent_list.at(j));
186 }
187 
189 {
190  vector <ResourceProvider*>::iterator iter;
191 
192  for (iter = host_list.begin(); iter!=host_list.end(); iter++)
193  {
194  if ((*iter)->trySchedulingTsk(tsk))
195  return (*iter)->getTskComAgent();
196 // return (host_agent_list.at((*iter)->id_));
197  }
198  return NULL;
199 }
200 
201 TskComAgent *DataCenter::scheduleRoundRobin(CloudTask *tsk,std::vector<TskComAgent*> agent_list)
202 {
203  int j = tskSubmitted_% agent_list.size();
204 
205  return (agent_list.at(j));
206 }
207 
209 {
210  vector <ResourceProvider*>::iterator iter;
211 
212  for (iter = vm_list.begin(); iter!=vm_list.end(); iter++)
213  {
214  if ((*iter)->trySchedulingTsk(tsk))
215  return (*iter)->getTskComAgent();
216 // return (vm_agent_list.at((*iter)->id_));
217  }
218  return NULL;
219 }
220 
221 int DataCenter::command(int argc, const char*const* argv)
222 {
223  if (argc == 2) {
224  if (strcmp(argv[1], "compute-load") == 0) {
225  computeLoad();
226  return (TCL_OK);
227  } else if (strcmp(argv[1], "print-resspec") == 0) {
229  return (TCL_OK);
230  } else if (strcmp(argv[1], "initially-configure-vms") == 0) {
231  if(initiallyConfigureVms() == 0){
232  return (TCL_OK);
233  } else {
234  return (TCL_ERROR);
235  }
236  } else if (strcmp(argv[1], "clear") == 0) {
237  clear();
238  return (TCL_OK);
239  } else if (strcmp(argv[1], "schedule-on-vms") == 0) {
240  setVmScheduling(true);
241  return (TCL_OK);
242  }
243  } else if (argc == 3) {
244  if (strcmp(argv[1], "add-dchost") == 0) {
245  DcHost *hst = dynamic_cast<DcHost*> (TclObject::lookup(argv[2]));
246  if(hst){
247  addHostPointer(hst);
248  return (TCL_OK);
249  }
250  return (TCL_ERROR);
251  } else if (strcmp(argv[1], "add-vm") == 0) {
252  VM *vm = dynamic_cast<VM*> (TclObject::lookup(argv[2]));
253  if(vm){
254  addVmPointer(vm);
255  return (TCL_OK);
256  }
257  return (TCL_ERROR);
258  }
259  else if (strcmp(argv[1], "add-hosttaskagent") == 0) {
260  TskComAgent *agnt = dynamic_cast<TskComAgent*> (TclObject::lookup(argv[2]));
261  if(agnt){
263  numHostTskAgents_ = (int) host_agent_list.size();
264  return (TCL_OK);
265  }
266  return (TCL_ERROR);
267  } else if (strcmp(argv[1], "add-vmtaskagent") == 0) {
268  TskComAgent *agnt = dynamic_cast<TskComAgent*> (TclObject::lookup(argv[2]));
269  if(agnt){
270  addVmTaskAgentPointer(agnt);
271  numVmTskAgents_= (int) vm_agent_list.size();
272  return (TCL_OK);
273  }
274  return (TCL_ERROR);
275  }
276  else if (strcmp(argv[1], "add-resspec") == 0) {
277  ResourceSpec *resspec = dynamic_cast<ResourceSpec*> (TclObject::lookup(argv[2]));
278  if(resspec){
280  return (TCL_OK);
281  }
282  return (TCL_ERROR);
283  } else if (strcmp(argv[1], "add-vresspec") == 0) {
284  ResourceSpec *resspec = dynamic_cast<ResourceSpec*> (TclObject::lookup(argv[2]));
285  if(resspec){
287  return (TCL_OK);
288  }
289  return (TCL_ERROR);
290  } else if (strcmp(argv[1], "add-pmodel") == 0) {
291  PowerModel *pmodel = dynamic_cast<PowerModel*> (TclObject::lookup(argv[2]));
292  if(pmodel){
293  addPModelPointer(pmodel);
294  return (TCL_OK);
295  }
296  return (TCL_ERROR);
297  } else if (strcmp(argv[1], "get-newest-migration") == 0) {
298  VmMigration *mig = dynamic_cast<VmMigration*> (TclObject::lookup(argv[2]));
299  if(mig){
300  tmp_migration_=mig;
301  return (TCL_OK);
302  }
303  return (TCL_ERROR);
304  } else if (strcmp(argv[1], "set-scheduler") == 0) {
305  if(setScheduler(argv[2])){
306  return (TCL_OK);
307  }
308  return (TCL_ERROR);
309  }
310  } else if (argc == 4) {
311  if (strcmp(argv[1], "configure-resource") == 0) {
312  DcResource *res = dynamic_cast<DcResource*> (TclObject::lookup(argv[2]));
313  if(res){
314  if(configureResource(res,argv[3])==0){
315  return (TCL_OK);
316  } else {
317  return (TCL_ERROR);
318  }
319  }
320  return (TCL_ERROR);
321  } else if (strcmp(argv[1], "configure-vresource") == 0) {
322  DcResource *res = dynamic_cast<DcResource*> (TclObject::lookup(argv[2]));
323  if(res){
324  if(configureVirtualResource(res,argv[3])==0){
325  return (TCL_OK);
326  } else {
327  return (TCL_ERROR);
328  }
329  }
330  return (TCL_ERROR);
331  } else if (strcmp(argv[1], "migrate-vm") == 0) {
332  VM *vm = dynamic_cast<VM*> (TclObject::lookup(argv[2]));
333  ResourceProvider *target = dynamic_cast<ResourceProvider*> (TclObject::lookup(argv[3]));
334  if(vm && target){
335  migrateVm( vm, target);
336  return (TCL_OK);
337  } else {
338  return (TCL_ERROR);
339  }
340  }
341  return (TCL_ERROR);
342 
343 
344  }
345  return (DataCenter::command(argc, argv));
346 }
347 
349 {
350  /* Traverse servers and compute their average load */
351  vector <ResourceProvider*>::iterator iter;
352 
353  double avgLoad = 0;
354  double avgLoadMem = 0;
355  double avgLoadStor = 0;
356  double avgPower = 0;
357  for (iter = host_list.begin(); iter!=host_list.end(); iter++)
358  {
359 
360  avgLoad += (*iter)->getResTypeUtil(Computing);
361  avgLoadMem += (*iter)->getResTypeUtil(Memory);
362  avgLoadStor += (*iter)->getResTypeUtil(Storage);
363  avgPower += ((DcHost*)(*iter))->eCurrentConsumption_;
364 
365  }
366 
367  for (iter = vm_list.begin(); iter!=vm_list.end(); iter++)
368  {
369  (*iter)->getResTypeUtil(Computing);
370  (*iter)->getResTypeUtil(Memory);
371  (*iter)->getResTypeUtil(Storage);
372  }
373 
374 
375 
376  avgLoad_ = avgLoad / host_list.size();
377  avgLoadMem_= avgLoadMem / host_list.size();
378  avgLoadStor_= avgLoadStor / host_list.size();
379  avgPower_= avgPower / host_list.size();
380 }
381 
383  vector <ResourceSpec*>::iterator iter;
384  for (iter = resource_specification_list.begin(); iter!=resource_specification_list.end(); iter++)
385  {
386  (*iter)->print();
387  }
388 
389 }
390 
391 int DataCenter::configureResource(DcResource* confRes, const char* spec_name){
392  vector <ResourceSpec*>::iterator iter;
393  int result = 1;
394  std::string test = spec_name;
395  for (iter = resource_specification_list.begin(); iter!=resource_specification_list.end(); iter++)
396  {
397  if((*iter)->name_==test){
398  result = 0;
399  break;
400  }
401  }
402  if(result==0){
403  confRes->setSpecification(*iter);
404  } else {
405  std::cerr << "ERROR: The requested resource specification is not registered in the data center!\n";
406  }
407  return result;
408 }
409 
410 int DataCenter::configureVirtualResource(DcResource* confRes, const char* spec_name){
411  vector <ResourceSpec*>::iterator iter;
412  int result = 1;
413  std::string test = spec_name;
414  for (iter = virt_resource_specification_list.begin(); iter!=virt_resource_specification_list.end(); iter++)
415  {
416  if((*iter)->name_==test){
417  result = 0;
418  break;
419  }
420  }
421  if(result==0){
422  confRes->setSpecification(*iter);
423  } else {
424  std::cerr << "ERROR: The requested virtual resource specification is not registered in the data center!\n";
425  }
426  return result;
427 }
428 
429 
void addHostTaskAgentPointer(TskComAgent *newagnt)
Definition: datacenter.cc:74
int configureResource(DcResource *confRes, const char *spec_name)
Definition: datacenter.cc:391
TskComAgent * scheduleGreen(CloudTask *tsk)
Definition: datacenter.cc:188
void setVmScheduling(bool scheduleOnVms)
Definition: datacenter.cc:61
int tskFailed_
Definition: datacenter.h:53
double avgPower_
Definition: datacenter.h:57
virtual void sendmsg(int nbytes, void *pTaskObj, const char *flags=0)
Definition: tskagent.h:21
int configureVirtualResource(DcResource *confRes, const char *spec_name)
Definition: datacenter.cc:410
double avgLoadStor_
Definition: datacenter.h:56
void clear()
Definition: datacenter.cc:40
TskComAgent * scheduleRoundRobin(CloudTask *tsk)
Definition: datacenter.cc:181
vector< TskComAgent * > vm_agent_list
Definition: datacenter.h:63
void addPModelPointer(PowerModel *newPModel)
Definition: datacenter.cc:91
TclObject * create(int argc, const char *const *argv)
Definition: datacenter.cc:17
void addVmTaskAgentPointer(TskComAgent *newagnt)
Definition: datacenter.cc:80
void startMigration()
Definition: vmmigration.cc:77
vector< PowerModel * > power_model_list
Definition: datacenter.h:64
void migrateVm(VM *vm, ResourceProvider *target)
Definition: datacenter.cc:151
void addResourceSpecificationPointer(ResourceSpec *newresspec)
Definition: datacenter.cc:86
vector< ResourceProvider * > host_list
Definition: datacenter.h:60
virtual TskComAgent * scheduleTask(CloudTask *task, std::vector< ResourceProvider * > providers)=0
void initalizeMigration(VM *vm, ResourceProvider *target)
Definition: vmmigration.cc:22
int numVmTskAgents_
Definition: datacenter.h:76
static const char rcsid[]
Definition: datacenter.cc:6
virtual void receivedTsk(int tsksize, CloudTask *pTask, const char *flags=0)
Definition: datacenter.cc:161
int numHostTskAgents_
Definition: datacenter.h:75
void computeLoad()
Definition: datacenter.cc:348
virtual int command(int argc, const char *const *argv)
Definition: datacenter.cc:221
VmMigration * tmp_migration_
Definition: datacenter.h:78
vector< ResourceProvider * > vm_list
Definition: datacenter.h:62
void addVmPointer(VM *newvm)
Definition: datacenter.cc:70
int initiallyConfigureVms()
Definition: datacenter.cc:101
void createNewMigration()
Definition: datacenter.cc:142
DataCenterClass class_datacenter
bool scheduleOnVms_
Definition: datacenter.h:87
void addVirtualResourceSpecificationPointer(ResourceSpec *newresspec)
Definition: datacenter.cc:96
Definition: dchost.h:27
vector< ResourceSpec * > virt_resource_specification_list
Definition: datacenter.h:71
vector< ResourceSpec * > resource_specification_list
Definition: datacenter.h:70
DcScheduler * dcScheduler
Definition: datacenter.h:66
double avgLoadMem_
Definition: datacenter.h:55
vector< TskComAgent * > host_agent_list
Definition: datacenter.h:61
virtual ~DataCenter()
Definition: datacenter.cc:35
virtual int setSpecification(ResourceSpec *resspec)
Definition: dcresource.cc:28
TskComAgent * scheduleGreenVmOnly(CloudTask *tsk)
Definition: datacenter.cc:208
void addHostPointer(DcHost *newhst)
Definition: datacenter.cc:65
int setScheduler(const char *scheduler_name)
Definition: datacenter.cc:111
double avgLoad_
Definition: datacenter.h:54
int tskSubmitted_
Definition: datacenter.h:52
Definition: vm.h:29
void printResourceSpecs()
Definition: datacenter.cc:382