scheduling_decision.cpp

Go to the documentation of this file.

#include <core/scheduling_decision.hpp>
#include <core/algorithm.hpp>

#include <typeinfo>
#include <iostream>

namespace hype{
   namespace core{

   /*
   SchedulingDecision::SchedulingDecision(const std::string& name_of_algorithm,
                                          const EstimatedTime& estimated_time_for_algorithm, 
                                          const Tuple& feature_values)
                                          : name_of_algorithm_(name_of_algorithm), 
                                            estimated_time_for_algorithm_(estimated_time_for_algorithm),
                                            feature_values_(feature_values)
   {

   }*/
   
      uint64_t getUniqueID(){
         static uint64_t counter=0; 
         return ++counter;
      }
   
      SchedulingDecision::SchedulingDecision(Algorithm& alg_ref,
                                          const EstimatedTime& estimated_time_for_algorithm, 
                                          const Tuple& feature_values)
                                          : //name_of_algorithm_(name_of_algorithm),
                                            alg_ref_(alg_ref),
                                            estimated_time_for_algorithm_(estimated_time_for_algorithm),
                                            feature_values_(feature_values),
                                            scheduling_id_(getUniqueID())
   {
      alg_ref.incrementNumberofDecisionsforThisAlgorithm();
   }
   
   SchedulingDecision::~SchedulingDecision(){
         //std::cout << "Ich geh dann mal... " << typeid(SchedulingDecision).name() << std::endl;
   }

   const std::string SchedulingDecision::getNameofChoosenAlgorithm() const{
      //return name_of_algorithm_;
      return alg_ref_.getName();
   }

   const EstimatedTime SchedulingDecision::getEstimatedExecutionTimeforAlgorithm() const{
      return estimated_time_for_algorithm_;
   }

   const Tuple SchedulingDecision::getFeatureValues() const{
      return feature_values_;
   }
   
   const DeviceSpecification SchedulingDecision::getDeviceSpecification() const throw(){
      return alg_ref_.getDeviceSpecification();
   }
   
   bool SchedulingDecision::operator==(const SchedulingDecision& sched_dec) const{
      //Scheduling Decisions are equal if and only if their (unique) ids are equal
      return this->scheduling_id_==sched_dec.scheduling_id_;
   }
   
   }; //end namespace core
}; //end namespace hype