#include <corescheduler.h>

Collaboration diagram for CoreScheduler:

[legend]

Public Member Functions
	CoreScheduler (Capacity nominal_mips_, Capacity available_mips_)

virtual	~CoreScheduler ()

void	setProvider (ResourceProvider *provider)

void	setDVFS (int eDVFS_enabled_)

double	getCurrentMIPS ()

double	getCurrentMIPSRecursive ()

double	getNominalMIPS ()

double	getAvailableMIPS ()

ResourceProvider *	getProvider ()

void	updateTskList (double c_mips)

void	updateTskList ()

void	removeCompleted ()

CloudTask *	removeTaskAlloc (std::vector< TaskAlloc * >::iterator &iter, bool executed)

void	removeTaskAlloc (TaskAlloc *ta)

void	removeFailedTaskAlloc (std::vector< TaskAlloc * >::iterator &iter, bool executed)

void	updateTskComputingRates (double c_mips)

double	getMostUrgentTaskRate ()

void	setComputingRate ()

int	getAllTasksNumber ()

void	assignTask (TaskAlloc *tskobj)

void	executeTask (TaskAlloc *tskobj)

bool	removeFromAssginedList (TaskAlloc *tskobj)

bool	removeAllocationsFromAssginedList (CloudTask *tskobj)

void	startTaskExecution (CloudTask *tskobj)

void	addVcoreScheduler (CoreScheduler *cs)

void	removeVcoreScheduler (CoreScheduler *cs)

CoreScheduler *	getHostScheduler ()

Private Attributes
Capacity *	nominal_mips_

Capacity *	available_mips_

double	current_mips_

ResourceProvider *	provider

std::vector< CoreScheduler * >	hosted_vcores_schedulers

std::vector< TaskAlloc * >	tasks_alloc_list_

std::vector< TaskAlloc * >	tasks_alloc_assigned_

CoreScheduler *	host_scheduler_

int	eDVFS_enabled_

int	tskAllocFailed_

Detailed Description

Definition at line 26 of file corescheduler.h.

Constructor & Destructor Documentation

CoreScheduler::CoreScheduler	(	Capacity *	nominal_mips_,
		Capacity *	available_mips_
	)

Definition at line 12 of file corescheduler.cc.

                                                                                 : current_mips_(0.0), host_scheduler_(NULL), tskAllocFailed_(0) {
                 this->nominal_mips_=nominal_mips_;
                 this->available_mips_=available_mips_;
                 tasks_alloc_list_.clear();
                 tasks_alloc_assigned_.clear();
                 hosted_vcores_schedulers.clear();
 
 }

CoreScheduler::~CoreScheduler ( )

virtual

Definition at line 23 of file corescheduler.cc.

                               {
                 std::vector <TaskAlloc*>::iterator task;
                 for(task = tasks_alloc_list_.begin(); task!=tasks_alloc_list_.end() ;task++){
                                 delete (*task);
                 }
                 tasks_alloc_list_.~vector();
                 for(task = tasks_alloc_assigned_.begin(); task!=tasks_alloc_assigned_.end() ;task++){
                                 delete (*task);
                 }
                 tasks_alloc_assigned_.~vector();
 }

Member Function Documentation

void CoreScheduler::addVcoreScheduler ( CoreScheduler * cs )

Definition at line 308 of file corescheduler.cc.

                                                       {
                 hosted_vcores_schedulers.push_back(cs);
                 cs->host_scheduler_ = this;
 }

void CoreScheduler::assignTask ( TaskAlloc * tskobj )

Definition at line 71 of file corescheduler.cc.

                                                {
                 tasks_alloc_assigned_.push_back(tskobj);
                 tskobj->setCoreScheduler(this);
 }

void CoreScheduler::executeTask ( TaskAlloc * tskobj )

Definition at line 76 of file corescheduler.cc.

                                                 {
                 tasks_alloc_list_.push_back(tskobj);            // add to the active tasks links
                 tskobj->setCoreScheduler(this);
 }

int CoreScheduler::getAllTasksNumber ( )

Definition at line 67 of file corescheduler.cc.

                                     {
                 return tasks_alloc_list_.size() + tasks_alloc_assigned_.size();
 }

double CoreScheduler::getAvailableMIPS ( )

Definition at line 59 of file corescheduler.cc.

                                       {
                 return *available_mips_;
 }

double CoreScheduler::getCurrentMIPS ( )

Definition at line 43 of file corescheduler.cc.

                                     {
                 return current_mips_;
 }

double CoreScheduler::getCurrentMIPSRecursive ( )

Definition at line 46 of file corescheduler.cc.

                                              {
                 double result = getCurrentMIPS();
                 std::vector<CoreScheduler*>::iterator iter;
                 int i = 1;
                 for(iter = hosted_vcores_schedulers.begin(); iter != hosted_vcores_schedulers.end();iter++){
                                 result += (*iter)->getCurrentMIPSRecursive();
                                 i++;
                 }
                 return result;
 }

CoreScheduler * CoreScheduler::getHostScheduler ( )

Definition at line 319 of file corescheduler.cc.

                                                {
                 return host_scheduler_;
 }

double CoreScheduler::getMostUrgentTaskRate ( )

Definition at line 201 of file corescheduler.cc.

 {
                 std::vector<TaskAlloc*>::iterator iter;
 
                 /* update what is already computing */
 
                 for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end(); iter++)
                 {
                                 (*iter)->updateMIPS();          // update what is already computing
                 }
                 /* remove completed */
                 removeCompleted();
 
                 /* Compute highest MIPS/deadline ratio */
                 double maxrate = 0.0;
 
                 /* get most urgent task rate from the execution list */
                 for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end();)
                 {
                                 if((double)((*iter)->getDeadline() - Scheduler::instance().clock())>0 && (*iter)->cloudTask->failed_==false){
                                                 double rate = (double)(*iter)->getMIPS()/(double)((*iter)->getDeadline() - Scheduler::instance().clock());
                                                 if(rate>maxrate){
                                                                 maxrate = rate;
                                                 }
                                                 iter++;
                                 }
                                 else {
                                                 removeFailedTaskAlloc(iter,true);
                                 }
                 }
 
                 /* get most urgent task rate from the in-fly list */
                 for (iter = tasks_alloc_assigned_.begin(); iter != tasks_alloc_assigned_.end();)
                 {
                                 if((double)((*iter)->getDeadline() - Scheduler::instance().clock())>0 && (*iter)->cloudTask->failed_==false){
                                                 double rate = (double)(*iter)->getMIPS()/(double)((*iter)->getDeadline() - Scheduler::instance().clock());
                                                 if(rate>maxrate){
                                                                 maxrate = rate;
                                                 }
                                                 iter++;
                                 } else {
                                                 removeFailedTaskAlloc(iter,false);
                                 }
                 }
                 if (maxrate > getAvailableMIPS()){return getAvailableMIPS();}
                 else{return maxrate;}
 }

double CoreScheduler::getNominalMIPS ( )

Definition at line 56 of file corescheduler.cc.

                                     {
                 return *nominal_mips_;
 }

ResourceProvider * CoreScheduler::getProvider ( )

Definition at line 63 of file corescheduler.cc.

                                              {
                 return provider;
 }

bool CoreScheduler::removeAllocationsFromAssginedList ( CloudTask * tskobj )

Definition at line 94 of file corescheduler.cc.

                                                                        {
                 vector<TaskAlloc*>::iterator iter;
                 bool found = false;
                 for (iter = tasks_alloc_assigned_.begin(); iter != tasks_alloc_assigned_.end();)
                 {
                                 /* task received remove from in-fly list */
                                 if ((*iter)->cloudTask->id_ == tskobj->id_) {
                                                 iter = tasks_alloc_assigned_.erase(iter);
                                                 found = true;
                                 } else {
                                                 iter++;
                                 }
                 }
                 return found;
 }

void CoreScheduler::removeCompleted ( )

Definition at line 173 of file corescheduler.cc.

 {
                 std::vector<TaskAlloc*>::iterator iter;
 
                 /* remove completed tasks from the execution list */
                 for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end();)
                 {
                                 /* task should be completed and remove it from the list */
                                 if ((*iter)->getMIPS() <= 1) {
                                                 CloudTask* ct = removeTaskAlloc(iter,true);
                                                 //check if finished:
                                                 if(ct->isFinished()){
                                                                 provider->releaseAllocation(ct);
                                                                 provider->sendTaskOutput(ct);
                                                 }
                                 }
                                 /*Task run over its deadline, remove it and mark as failed. */
                                 else if(Scheduler::instance().clock() >= (*iter)->cloudTask->getDeadline()) {
                                                 removeFailedTaskAlloc(iter,true);
                                 } else if ((*iter)->cloudTask->failed_==true){
                                                 std::cerr << "This should not happen!\n";
                                 }
                                 else {
                                                 iter++;
                                 }
                 }
 }

void CoreScheduler::removeFailedTaskAlloc	(	std::vector< TaskAlloc * >::iterator &	iter,
		bool	executed
	)

Definition at line 158 of file corescheduler.cc.

 {
                 if((*iter)->cloudTask->failed_==false){
                                 (*iter)->cloudTask->fail(this->provider);
                 }
                 // REMOVE ALL TASK ALLOCATIONS FOR THE CLOUDTASK OF THIS TASK_ALLOC
                 if(executed){
                                 iter = tasks_alloc_list_.begin();
                 } else {
                                 iter = tasks_alloc_assigned_.begin();
                 }
 }

bool CoreScheduler::removeFromAssginedList ( TaskAlloc * tskobj )

Definition at line 81 of file corescheduler.cc.

                                                             {
                 vector<TaskAlloc*>::iterator iter;
                 for (iter = tasks_alloc_assigned_.begin(); iter != tasks_alloc_assigned_.end();iter++)
                 {
                                 /* task received remove from in-fly list */
                                 if ((*iter) == tskobj) {
                                                 tasks_alloc_assigned_.erase(iter);
                                                 return true;
                                 }
                 }
                 return false;
 }

CloudTask* CoreScheduler::removeTaskAlloc	(	std::vector< TaskAlloc * >::iterator &	iter,
		bool	executed
	)

void CoreScheduler::removeTaskAlloc ( TaskAlloc * ta )

Definition at line 148 of file corescheduler.cc.

 {
                 this->provider->updateEnergyAndConsumption();
                 tskAllocFailed_++;
                 tasks_alloc_list_.erase(remove(tasks_alloc_list_.begin(),tasks_alloc_list_.end(),ta),
                                                 tasks_alloc_list_.end()); /*erase-remove idiom*/
                 tasks_alloc_assigned_.erase(remove(tasks_alloc_assigned_.begin(),tasks_alloc_assigned_.end(),ta),
                                                 tasks_alloc_assigned_.end()); /*erase-remove idiom*/
 }

void CoreScheduler::removeVcoreScheduler ( CoreScheduler * cs )

Definition at line 313 of file corescheduler.cc.

                                                          {
                 hosted_vcores_schedulers.erase(remove(hosted_vcores_schedulers.begin(),hosted_vcores_schedulers.end(),cs),
                                                 hosted_vcores_schedulers.end()); /*erase-remove idiom*/
                 cs->host_scheduler_ = NULL;
 }

void CoreScheduler::setComputingRate ( )

Definition at line 294 of file corescheduler.cc.

 {
                 if (eDVFS_enabled_) {
                                 /* Max requested rate times the number of active taks */
                                 current_mips_ = getMostUrgentTaskRate()* tasks_alloc_list_.size();
                 } else {
                                 /* no energy saving */
                                 if (tasks_alloc_list_.size() != 0){current_mips_ = getAvailableMIPS();}
                                 else {(current_mips_) = 0;}
                 }
                 /* new computing rate, report it to tasks */
                 updateTskComputingRates(current_mips_);
 }

void CoreScheduler::setDVFS ( int eDVFS_enabled_ )

Definition at line 39 of file corescheduler.cc.

                                              {
                 this->eDVFS_enabled_ = eDVFS_enabled_;
 }

void CoreScheduler::setProvider ( ResourceProvider * provider )

Definition at line 35 of file corescheduler.cc.

                                                           {
                 this->provider = provider;
 }

void CoreScheduler::startTaskExecution ( CloudTask * tskobj )

Definition at line 110 of file corescheduler.cc.

                                                         {
                 vector<TaskAlloc*>::iterator iter;
                 for (iter = tasks_alloc_assigned_.begin(); iter != tasks_alloc_assigned_.end();)
                 {
                                 /* task received remove from in-fly list */
                                 if ((*iter)->cloudTask->id_ == tskobj->id_) {
                                                 executeTask((*iter));
                                                 (*iter)->setExecTime(Scheduler::instance().clock());
                                                 iter = tasks_alloc_assigned_.erase(iter);
 
                                 } else {
                                                 iter++;
                                 }
                 }
                 if(!tskobj->started_){
                                 tskobj->started_ = true;
                 }
                 this->updateTskList();
 }

void CoreScheduler::updateTskComputingRates ( double c_mips )

Definition at line 251 of file corescheduler.cc.

 {
                 vector<TaskAlloc*>::iterator iter;
 
 
                 for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end(); iter++)
                 {
                                 /* each task with then update mips left */
                                 (*iter)->setComputingRate((double)c_mips/tasks_alloc_list_.size());
                 }
 }

void CoreScheduler::updateTskList ( double c_mips )

Definition at line 263 of file corescheduler.cc.

 {
 
                 vector<TaskAlloc*>::iterator iter;
                 if (tasks_alloc_list_.size()==0) return;
 //              std::cout << "Prov: " << provider->id_ << "\n";
                 /* update task computing rates to see which tasks are completed */
                 updateTskComputingRates(c_mips);
                 removeCompleted();
 
                 /* set server computing rate */
                 setComputingRate();
 
                 /* compute next deadline */
                 double nextDeadline = DBL_MAX;
                 for (iter = tasks_alloc_list_.begin(); iter != tasks_alloc_list_.end(); iter++)
                 {
                                 if (nextDeadline > (*iter)->execTime()){
                                                 nextDeadline = (*iter)->execTime();
                                 }
                 }
 
 
                 provider->scheduleNextExent(nextDeadline);
 
 }

void CoreScheduler::updateTskList ( )

Definition at line 290 of file corescheduler.cc.

                                  {
                 updateTskList(this->current_mips_);
 }

Member Data Documentation

Capacity* CoreScheduler::available_mips_

private

MIPS unavailable for this scheduler (reserved for hosted vms)

Definition at line 64 of file corescheduler.h.

double CoreScheduler::current_mips_

private

MIPS currently used by this scheduler

Definition at line 65 of file corescheduler.h.

int CoreScheduler::eDVFS_enabled_

private

DVFS flag, influences the scheduling policy

Definition at line 72 of file corescheduler.h.

CoreScheduler* CoreScheduler::host_scheduler_

private

The scheduler that hosts this (next level) scheduler

Definition at line 71 of file corescheduler.h.

std::vector<CoreScheduler *> CoreScheduler::hosted_vcores_schedulers

private

List of schedulers of hosted vcores

Definition at line 68 of file corescheduler.h.

Capacity* CoreScheduler::nominal_mips_

private

Maximal available MIPS from ResourceSpec

Definition at line 63 of file corescheduler.h.

ResourceProvider* CoreScheduler::provider

private

The resorce provider that uses the scheduler

Definition at line 67 of file corescheduler.h.

std::vector<TaskAlloc *> CoreScheduler::tasks_alloc_assigned_

private

in-fly list

Definition at line 70 of file corescheduler.h.

std::vector<TaskAlloc *> CoreScheduler::tasks_alloc_list_

private

execution list

Definition at line 69 of file corescheduler.h.

int CoreScheduler::tskAllocFailed_

private

Number of TaskAllocations that failed on this scheduler (not used yet)

Definition at line 73 of file corescheduler.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation