algorithm.cpp

Go to the documentation of this file.

#include <config/configuration.hpp>

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

using namespace std;

namespace hype{
   namespace core{

         Algorithm::Algorithm(const std::string& name_of_algorithm, 
                   const std::string& name_of_statistical_method, 
                   const std::string& name_of_recomputation_strategy,
                   Operation& operation,
                   DeviceSpecification comp_dev)                               : name_(name_of_algorithm), 
                                                                        ptr_statistical_method_(getNewStatisticalMethodbyName(name_of_statistical_method)),
                                                                        ptr_recomputation_heristic_(
                                                                           getNewRecomputationHeuristicbyName(name_of_recomputation_strategy)
                                                                        ),
                                                                        statistics_(),
                                                                        operation_(operation),
                                                                        logical_timestamp_of_last_execution_(0),
                                                                        is_in_retraining_phase_(false),
                                                                        retraining_length_(0), 
                                                                        load_change_estimator_(10),
                                                                        comp_dev_(comp_dev)
         {

            if(ptr_statistical_method_==NULL || ptr_recomputation_heristic_==NULL) 
               std::cout << "Fatal Error!" << std::endl;
               
            //getNewStatisticalMethodbyName(name_of_statistical_method);

         }

         Algorithm::~Algorithm(){
            if(Runtime_Configuration::instance().printAlgorithmStatistics()){
               if(!statistics_.writeToDisc(operation_.getName(),name_))
                  cout << "Error! Could not write statistics for algorithm" << name_ << " to disc!" << endl;
            }
         }

         bool Algorithm::setStatisticalMethod(std::tr1::shared_ptr<StatisticalMethod_Internal> ptr_statistical_method){
            if(ptr_statistical_method){
               ptr_statistical_method_.reset();
               ptr_statistical_method_=ptr_statistical_method;
               //ptr_statistical_method_.reset(ptr_statistical_method);
               return true;
            }else{
               cout << "Error! in setStatisticalMethod(): ptr_statistical_method==NULL !" << endl;
               return false;
            }  
         }

         bool Algorithm::inTrainingPhase() const throw(){
            return ptr_statistical_method_->inTrainingPhase();
         }

         bool Algorithm::inRetrainingPhase() const throw(){
            return is_in_retraining_phase_;
         }

         bool Algorithm::setRecomputationHeuristic(std::tr1::shared_ptr<RecomputationHeuristic_Internal> ptr_recomputation_heristic){
            if(ptr_recomputation_heristic){
               ptr_recomputation_heristic_.reset();
               ptr_recomputation_heristic_=ptr_recomputation_heristic;
               //ptr_recomputation_heristic_.reset(ptr_recomputation_heristic);
               return true;
            }else{
               cout << "Error! in setRecomputationHeuristic(): ptr_recomputation_heristic==NULL !" << endl;
               return false;
            }  
            return true;
         }

         const std::string Algorithm::getName() const{
            return name_;
         }

         bool Algorithm::addMeasurementPair(const MeasurementPair& mp){
            //logical_timestamp_of_last_execution_=operation_.getNextTimestamp(); //after each execution of algorithm, add new timestamp (logical time form logical clock that is increased with every operation execution! -> Means, that each algorithms increments the timestamp by calling getNextTimestamp())
            if(!this->inTrainingPhase())           
               load_change_estimator_.add(mp);//first we have to learn the current load situation properly, afterwards, we can compute meaningful Load modifications

            if(ptr_recomputation_heristic_->recompute(*this)){
               if(!ptr_statistical_method_->recomuteApproximationFunction(*this)){
                  if(!quiet && verbose) cout << "Error while recomputing approximation function of algorithm '"  << name_ << "'" << endl;
               }else{
                  //success
                  if(!quiet && verbose) 
                     cout << "Successfully recomputed approximation function of algorithm '"  << name_ << "'"  << endl;
                  statistics_.number_of_recomputations_++; //update statistics
               }                                   
            }
            //if an observation was added, the model obviously decided to execute this algorithm
            //this->statistics_.number_of_decisions_for_this_algorithm_++;
            
            this->statistics_.number_of_terminated_executions_of_this_algorithm_++;
            
            this->statistics_.total_execution_time_+=mp.getMeasuredTime().getTimeinNanoseconds();
            
            this->statistics_.relative_errors_.push_back( (mp.getMeasuredTime().getTimeinNanoseconds()-mp.getEstimatedTime().getTimeinNanoseconds())
                                                           /mp.getEstimatedTime().getTimeinNanoseconds()
                                                         );

//          (measured_time.getTimeinNanoseconds()-scheduling_decision_.getEstimatedExecutionTimeforAlgorithm().getTimeinNanoseconds())/scheduling_decision_.getEstimatedExecutionTimeforAlgorithm().getTimeinNanoseconds() << "%" << endl; 
            
            if(is_in_retraining_phase_){
               //if(Configuration::maximal_retraining_length>=retraining_length_++){
               if(Runtime_Configuration::instance().getRetrainingLength()>=retraining_length_++){
                  is_in_retraining_phase_=false;
                  if(!quiet) cout << "Finished retraining" << endl;
                  //ptr_statistical_method_->recomuteApproximationFunction(*this);
               }
            }
            
            return statistics_.executionHistory_.addMeasurementPair(mp);
         }

         const EstimatedTime Algorithm::getEstimatedExecutionTime(const Tuple& input_values){
            return ptr_statistical_method_->computeEstimation(input_values);
         }
   
         unsigned int Algorithm::getNumberOfDecisionsforThisAlgorithm() const throw(){
            return this->statistics_.number_of_decisions_for_this_algorithm_;
         }
      
         unsigned int Algorithm::getNumberOfTerminatedExecutions() const throw(){
            return this->statistics_.number_of_terminated_executions_of_this_algorithm_;
         }
      
         double Algorithm::getTotalExecutionTime() const throw(){
            return statistics_.total_execution_time_;
         }
         
         uint64_t Algorithm::getTimeOfLastExecution() const throw(){
            return logical_timestamp_of_last_execution_;
         }
         
         void Algorithm::setTimeOfLastExecution(uint64_t new_timestamp) throw(){
            this->logical_timestamp_of_last_execution_=new_timestamp;
         }  
         
         void Algorithm::incrementNumberofDecisionsforThisAlgorithm() throw(){
            this->statistics_.number_of_decisions_for_this_algorithm_++;
         }
         
         void Algorithm::retrain(){
            if(!quiet) std::cout << "Retrain algorithm " << name_ << std::endl;
            is_in_retraining_phase_=true;
            retraining_length_=0;
            //ptr_statistical_method_->retrain();
            
            //this->statistics_.executionHistory_.clear();
         }

      const LoadChangeEstimator& Algorithm::getLoadChangeEstimator() const throw(){
         return load_change_estimator_;
      }
      
      const DeviceSpecification Algorithm::getDeviceSpecification() const throw(){
         return comp_dev_;
      }

   }; //end namespace core
}; //end namespace hype