GreenCloud Simulator
Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
DataCenter Class Reference

#include <datacenter.h>

Inheritance diagram for DataCenter:
Inheritance graph
[legend]
Collaboration diagram for DataCenter:
Collaboration graph
[legend]

Public Member Functions

 DataCenter ()
 
virtual ~DataCenter ()
 
void clear ()
 
void addHostPointer (DcHost *newhst)
 
void addVmPointer (VM *newvm)
 
void addHostTaskAgentPointer (TskComAgent *newagnt)
 
void addVmTaskAgentPointer (TskComAgent *newagnt)
 
void addResourceSpecificationPointer (ResourceSpec *newresspec)
 
void addVirtualResourceSpecificationPointer (ResourceSpec *newresspec)
 
void addPModelPointer (PowerModel *newPModel)
 
int initiallyConfigureVms ()
 
int setScheduler (const char *scheduler_name)
 
void migrateVm (VM *vm, ResourceProvider *target)
 
int configureResource (DcResource *confRes, const char *spec_name)
 
int configureVirtualResource (DcResource *confRes, const char *spec_name)
 
void printResourceSpecs ()
 
virtual void receivedTsk (int tsksize, CloudTask *pTask, const char *flags=0)
 
virtual int command (int argc, const char *const *argv)
 

Public Attributes

int tskSubmitted_
 
int tskFailed_
 
double avgLoad_
 
double avgLoadMem_
 
double avgLoadStor_
 
double avgPower_
 

Protected Member Functions

TskComAgent * scheduleRoundRobin (CloudTask *tsk)
 
TskComAgent * scheduleRoundRobin (CloudTask *tsk, std::vector< TskComAgent * > agent_list)
 
TskComAgent * scheduleGreen (CloudTask *tsk)
 
TskComAgent * scheduleGreenVmOnly (CloudTask *tsk)
 
void computeLoad ()
 
void setVmScheduling (bool scheduleOnVms)
 

Protected Attributes

vector< ResourceProvider * > host_list
 
vector< TskComAgent * > host_agent_list
 
vector< ResourceProvider * > vm_list
 
vector< TskComAgent * > vm_agent_list
 
vector< PowerModel * > power_model_list
 
DcScheduler * dcScheduler
 
vector< ResourceSpec * > resource_specification_list
 
vector< ResourceSpec * > virt_resource_specification_list
 
DcHost * newhost_
 
int numHostTskAgents_
 
int numVmTskAgents_
 
VmMigration * tmp_migration_
 
bool scheduleOnVms_
 

Private Member Functions

void createNewMigration ()
 

Detailed Description

Definition at line 27 of file datacenter.h.

Constructor & Destructor Documentation

DataCenter::DataCenter ( )

Definition at line 22 of file datacenter.cc.

22  : 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 }
DataCenter::tskFailed_
int tskFailed_
Definition: datacenter.h:53
DataCenter::avgPower_
double avgPower_
Definition: datacenter.h:57
DataCenter::avgLoadStor_
double avgLoadStor_
Definition: datacenter.h:56
DataCenter::numVmTskAgents_
int numVmTskAgents_
Definition: datacenter.h:76
DataCenter::numHostTskAgents_
int numHostTskAgents_
Definition: datacenter.h:75
DataCenter::scheduleOnVms_
bool scheduleOnVms_
Definition: datacenter.h:87
DataCenter::dcScheduler
DcScheduler * dcScheduler
Definition: datacenter.h:66
DataCenter::avgLoadMem_
double avgLoadMem_
Definition: datacenter.h:55
DataCenter::avgLoad_
double avgLoad_
Definition: datacenter.h:54
DataCenter::tskSubmitted_
int tskSubmitted_
Definition: datacenter.h:52
DataCenter::~DataCenter ( )
virtual

Definition at line 35 of file datacenter.cc.

36 {
37  clear();
38 }
DataCenter::clear
void clear()
Definition: datacenter.cc:40

Member Function Documentation

void DataCenter::addHostPointer ( DcHost *  newhst)

Definition at line 65 of file datacenter.cc.

66 {
67  host_list.push_back(newhst);
68 }
DataCenter::host_list
vector< ResourceProvider * > host_list
Definition: datacenter.h:60
void DataCenter::addHostTaskAgentPointer ( TskComAgent *  newagnt)

Definition at line 74 of file datacenter.cc.

75 {
76  newagnt->set_pkttype(PT_CLOUD_USER);
77  host_agent_list.push_back(newagnt);
78 }
DataCenter::host_agent_list
vector< TskComAgent * > host_agent_list
Definition: datacenter.h:61
void DataCenter::addPModelPointer ( PowerModel *  newPModel)

Register power model in Data Center.

Definition at line 91 of file datacenter.cc.

91  {
92  power_model_list.push_back(newPModel);
93 }
DataCenter::power_model_list
vector< PowerModel * > power_model_list
Definition: datacenter.h:64
void DataCenter::addResourceSpecificationPointer ( ResourceSpec *  newresspec)

Registers resource used in Data Center.

Definition at line 86 of file datacenter.cc.

87 {
88  resource_specification_list.push_back(newresspec);
89 }
DataCenter::resource_specification_list
vector< ResourceSpec * > resource_specification_list
Definition: datacenter.h:70
void DataCenter::addVirtualResourceSpecificationPointer ( ResourceSpec *  newresspec)

Registers virtual resource used in Data Center.

Definition at line 96 of file datacenter.cc.

97 {
98  virt_resource_specification_list.push_back(newresspec);
99 }
DataCenter::virt_resource_specification_list
vector< ResourceSpec * > virt_resource_specification_list
Definition: datacenter.h:71
void DataCenter::addVmPointer ( VM *  newvm)

Definition at line 70 of file datacenter.cc.

70  {
71  vm_list.push_back(newvm);
72 }
DataCenter::vm_list
vector< ResourceProvider * > vm_list
Definition: datacenter.h:62
void DataCenter::addVmTaskAgentPointer ( TskComAgent *  newagnt)

Definition at line 80 of file datacenter.cc.

81 {
82  newagnt->set_pkttype(PT_CLOUD_USER);
83  vm_agent_list.push_back(newagnt);
84 }
DataCenter::vm_agent_list
vector< TskComAgent * > vm_agent_list
Definition: datacenter.h:63
void DataCenter::clear ( )

Definition at line 40 of file datacenter.cc.

40  {
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  }
49  resource_specification_list.clear();
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 }
DataCenter::host_list
vector< ResourceProvider * > host_list
Definition: datacenter.h:60
DataCenter::vm_list
vector< ResourceProvider * > vm_list
Definition: datacenter.h:62
DataCenter::resource_specification_list
vector< ResourceSpec * > resource_specification_list
Definition: datacenter.h:70
DataCenter::host_agent_list
vector< TskComAgent * > host_agent_list
Definition: datacenter.h:61
int DataCenter::command ( int  argc,
const char *const *  argv 
)
virtual

Definition at line 221 of file datacenter.cc.

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) {
228  printResourceSpecs();
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){
262  addHostTaskAgentPointer(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){
279  addResourceSpecificationPointer(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){
286  addVirtualResourceSpecificationPointer(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 }
DataCenter::addHostTaskAgentPointer
void addHostTaskAgentPointer(TskComAgent *newagnt)
Definition: datacenter.cc:74
DataCenter::configureResource
int configureResource(DcResource *confRes, const char *spec_name)
Definition: datacenter.cc:391
DataCenter::setVmScheduling
void setVmScheduling(bool scheduleOnVms)
Definition: datacenter.cc:61
DataCenter::configureVirtualResource
int configureVirtualResource(DcResource *confRes, const char *spec_name)
Definition: datacenter.cc:410
DataCenter::clear
void clear()
Definition: datacenter.cc:40
DataCenter::vm_agent_list
vector< TskComAgent * > vm_agent_list
Definition: datacenter.h:63
DataCenter::addPModelPointer
void addPModelPointer(PowerModel *newPModel)
Definition: datacenter.cc:91
DataCenter::addVmTaskAgentPointer
void addVmTaskAgentPointer(TskComAgent *newagnt)
Definition: datacenter.cc:80
DataCenter::migrateVm
void migrateVm(VM *vm, ResourceProvider *target)
Definition: datacenter.cc:151
DataCenter::addResourceSpecificationPointer
void addResourceSpecificationPointer(ResourceSpec *newresspec)
Definition: datacenter.cc:86
DataCenter::numVmTskAgents_
int numVmTskAgents_
Definition: datacenter.h:76
DataCenter::numHostTskAgents_
int numHostTskAgents_
Definition: datacenter.h:75
DataCenter::computeLoad
void computeLoad()
Definition: datacenter.cc:348
DataCenter::command
virtual int command(int argc, const char *const *argv)
Definition: datacenter.cc:221
DataCenter::tmp_migration_
VmMigration * tmp_migration_
Definition: datacenter.h:78
DataCenter::addVmPointer
void addVmPointer(VM *newvm)
Definition: datacenter.cc:70
DataCenter::initiallyConfigureVms
int initiallyConfigureVms()
Definition: datacenter.cc:101
DataCenter::addVirtualResourceSpecificationPointer
void addVirtualResourceSpecificationPointer(ResourceSpec *newresspec)
Definition: datacenter.cc:96
DcHost
Definition: dchost.h:27
DataCenter::host_agent_list
vector< TskComAgent * > host_agent_list
Definition: datacenter.h:61
DataCenter::addHostPointer
void addHostPointer(DcHost *newhst)
Definition: datacenter.cc:65
DataCenter::setScheduler
int setScheduler(const char *scheduler_name)
Definition: datacenter.cc:111
VM
Definition: vm.h:29
DataCenter::printResourceSpecs
void printResourceSpecs()
Definition: datacenter.cc:382
void DataCenter::computeLoad ( )
protected

Definition at line 348 of file datacenter.cc.

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 }
DataCenter::avgPower_
double avgPower_
Definition: datacenter.h:57
DataCenter::avgLoadStor_
double avgLoadStor_
Definition: datacenter.h:56
DataCenter::host_list
vector< ResourceProvider * > host_list
Definition: datacenter.h:60
DataCenter::vm_list
vector< ResourceProvider * > vm_list
Definition: datacenter.h:62
DcHost
Definition: dchost.h:27
DataCenter::avgLoadMem_
double avgLoadMem_
Definition: datacenter.h:55
DataCenter::avgLoad_
double avgLoad_
Definition: datacenter.h:54
int DataCenter::configureResource ( DcResource *  confRes,
const char *  spec_name 
)

Definition at line 391 of file datacenter.cc.

391  {
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 }
DataCenter::resource_specification_list
vector< ResourceSpec * > resource_specification_list
Definition: datacenter.h:70
DcResource::setSpecification
virtual int setSpecification(ResourceSpec *resspec)
Definition: dcresource.cc:28
int DataCenter::configureVirtualResource ( DcResource *  confRes,
const char *  spec_name 
)

Definition at line 410 of file datacenter.cc.

410  {
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 }
DataCenter::virt_resource_specification_list
vector< ResourceSpec * > virt_resource_specification_list
Definition: datacenter.h:71
DcResource::setSpecification
virtual int setSpecification(ResourceSpec *resspec)
Definition: dcresource.cc:28
void DataCenter::createNewMigration ( )
private

Definition at line 142 of file datacenter.cc.

142  {
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 }
int DataCenter::initiallyConfigureVms ( )

TODO: Dynamically configure the initial state of VMs.

Definition at line 101 of file datacenter.cc.

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 }
void DataCenter::migrateVm ( VM *  vm,
ResourceProvider *  target 
)

Definition at line 151 of file datacenter.cc.

151  {
152  createNewMigration(); // Creates and sets new migrations as tmp_migration_
153  tmp_migration_->initalizeMigration(vm,target);
154 
155  tmp_migration_->startMigration();
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 }
VmMigration::startMigration
void startMigration()
Definition: vmmigration.cc:77
VmMigration::initalizeMigration
void initalizeMigration(VM *vm, ResourceProvider *target)
Definition: vmmigration.cc:22
DataCenter::tmp_migration_
VmMigration * tmp_migration_
Definition: datacenter.h:78
DataCenter::createNewMigration
void createNewMigration()
Definition: datacenter.cc:142
void DataCenter::printResourceSpecs ( )

Definition at line 382 of file datacenter.cc.

382  {
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 }
DataCenter::resource_specification_list
vector< ResourceSpec * > resource_specification_list
Definition: datacenter.h:70
void DataCenter::receivedTsk ( int  tsksize,
CloudTask *  pTask,
const char *  flags = 0 
)
virtual

Definition at line 161 of file datacenter.cc.

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 }
DataCenter::tskFailed_
int tskFailed_
Definition: datacenter.h:53
TskComAgent::sendmsg
virtual void sendmsg(int nbytes, void *pTaskObj, const char *flags=0)
Definition: tskagent.h:21
DataCenter::host_list
vector< ResourceProvider * > host_list
Definition: datacenter.h:60
DcScheduler::scheduleTask
virtual TskComAgent * scheduleTask(CloudTask *task, std::vector< ResourceProvider * > providers)=0
DataCenter::vm_list
vector< ResourceProvider * > vm_list
Definition: datacenter.h:62
DataCenter::scheduleOnVms_
bool scheduleOnVms_
Definition: datacenter.h:87
DataCenter::dcScheduler
DcScheduler * dcScheduler
Definition: datacenter.h:66
DataCenter::tskSubmitted_
int tskSubmitted_
Definition: datacenter.h:52
TskComAgent * DataCenter::scheduleGreen ( CloudTask *  tsk)
protected

Definition at line 188 of file datacenter.cc.

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 }
DataCenter::host_list
vector< ResourceProvider * > host_list
Definition: datacenter.h:60
TskComAgent * DataCenter::scheduleGreenVmOnly ( CloudTask *  tsk)
protected

Definition at line 208 of file datacenter.cc.

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 }
DataCenter::vm_list
vector< ResourceProvider * > vm_list
Definition: datacenter.h:62
TskComAgent * DataCenter::scheduleRoundRobin ( CloudTask *  tsk)
protected

Definition at line 181 of file datacenter.cc.

182 {
183  int j = tskSubmitted_% numHostTskAgents_;
184 
185  return (host_agent_list.at(j));
186 }
DataCenter::numHostTskAgents_
int numHostTskAgents_
Definition: datacenter.h:75
DataCenter::host_agent_list
vector< TskComAgent * > host_agent_list
Definition: datacenter.h:61
DataCenter::tskSubmitted_
int tskSubmitted_
Definition: datacenter.h:52
TskComAgent * DataCenter::scheduleRoundRobin ( CloudTask *  tsk,
std::vector< TskComAgent * >  agent_list 
)
protected

Definition at line 201 of file datacenter.cc.

202 {
203  int j = tskSubmitted_% agent_list.size();
204 
205  return (agent_list.at(j));
206 }
DataCenter::tskSubmitted_
int tskSubmitted_
Definition: datacenter.h:52
int DataCenter::setScheduler ( const char *  scheduler_name)

Release old DcScheduler, and create and set new by name

Definition at line 111 of file datacenter.cc.

111  {
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){
120  dcScheduler = new RoundRobinsScheduler();
121  return 1;
122  } else if(strcmp(scheduler_name, "Random") == 0){
123  dcScheduler = new RandomScheduler();
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 }
DataCenter::dcScheduler
DcScheduler * dcScheduler
Definition: datacenter.h:66
void DataCenter::setVmScheduling ( bool  scheduleOnVms)
protected

Definition at line 61 of file datacenter.cc.

61  {
62  this->scheduleOnVms_ = scheduleOnVms;
63 }
DataCenter::scheduleOnVms_
bool scheduleOnVms_
Definition: datacenter.h:87

Member Data Documentation

double DataCenter::avgLoad_

Definition at line 54 of file datacenter.h.

double DataCenter::avgLoadMem_

Definition at line 55 of file datacenter.h.

double DataCenter::avgLoadStor_

Definition at line 56 of file datacenter.h.

double DataCenter::avgPower_

Definition at line 57 of file datacenter.h.

DcScheduler* DataCenter::dcScheduler
protected

Definition at line 66 of file datacenter.h.

vector<TskComAgent*> DataCenter::host_agent_list
protected

Definition at line 61 of file datacenter.h.

vector<ResourceProvider*> DataCenter::host_list
protected

Definition at line 60 of file datacenter.h.

DcHost* DataCenter::newhost_
protected

Definition at line 73 of file datacenter.h.

int DataCenter::numHostTskAgents_
protected

Definition at line 75 of file datacenter.h.

int DataCenter::numVmTskAgents_
protected

Definition at line 76 of file datacenter.h.

vector<PowerModel*> DataCenter::power_model_list
protected

Definition at line 64 of file datacenter.h.

vector< ResourceSpec* > DataCenter::resource_specification_list
protected

Definition at line 70 of file datacenter.h.

bool DataCenter::scheduleOnVms_
protected

Definition at line 87 of file datacenter.h.

VmMigration* DataCenter::tmp_migration_
protected

Definition at line 78 of file datacenter.h.

int DataCenter::tskFailed_

Definition at line 53 of file datacenter.h.

int DataCenter::tskSubmitted_

Definition at line 52 of file datacenter.h.

vector< ResourceSpec* > DataCenter::virt_resource_specification_list
protected

Definition at line 71 of file datacenter.h.

vector<TskComAgent*> DataCenter::vm_agent_list
protected

Definition at line 63 of file datacenter.h.

vector<ResourceProvider*> DataCenter::vm_list
protected

Definition at line 62 of file datacenter.h.

The documentation for this class was generated from the following files:
Generated on Sat Jan 30 2016 10:58:40 for GreenCloud Simulator by   doxygen 1.8.11