algorithm.hpp

Go to the documentation of this file.

/***********************************************************************************************************
Copyright (c) 2012, Sebastian Breß, Otto-von-Guericke University of Magdeburg, Germany. All rights reserved.

This program and accompanying materials are made available under the terms of the 
GNU LESSER GENERAL PUBLIC LICENSE - Version 3, http://www.gnu.org/licenses/lgpl-3.0.txt
***********************************************************************************************************/
#pragma once

#include <config/global_definitions.hpp>

#include <memory>
#include <vector>
#include <core/specification.hpp>
#include <core/statistical_method.hpp>
#include <core/recomputation_heuristic.hpp>
#include <core/time_measurement.hpp>
#include <core/algorithm_statistics.hpp>
#include <core/loadchange_estimator.hpp>
namespace hype{
   namespace core{

//forward declaration
class Operation;

      class Algorithm{

         public:
         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);
                   
         ~Algorithm();

         bool setStatisticalMethod(std::tr1::shared_ptr<StatisticalMethod_Internal> ptr_statistical_method);

         bool setRecomputationHeuristic(std::tr1::shared_ptr<RecomputationHeuristic_Internal> ptr_recomp_heuristic);

         const std::string getName() const; 

         const EstimatedTime getEstimatedExecutionTime(const Tuple& input_values);
   
         unsigned int getNumberOfDecisionsforThisAlgorithm() const throw();      
         unsigned int getNumberOfTerminatedExecutions() const throw();
         double getTotalExecutionTime() const throw();

         bool addMeasurementPair(const MeasurementPair& mp);

         AlgorithmStatistics& getAlgorithmStatistics(){
            return statistics_;
         }
         
         bool inTrainingPhase() const throw();
         bool inRetrainingPhase() const throw();
         uint64_t getTimeOfLastExecution() const throw();
         void setTimeOfLastExecution(uint64_t new_timestamp) throw();
         void incrementNumberofDecisionsforThisAlgorithm() throw();
   
         void retrain();
         const LoadChangeEstimator& getLoadChangeEstimator() const throw();
         const DeviceSpecification getDeviceSpecification() const throw(); 

         private:
         std::string name_;
         std::tr1::shared_ptr<StatisticalMethod_Internal> ptr_statistical_method_;
         std::tr1::shared_ptr<RecomputationHeuristic_Internal> ptr_recomputation_heristic_;
         AlgorithmStatistics statistics_;
         Operation& operation_;
         uint64_t logical_timestamp_of_last_execution_;
         bool is_in_retraining_phase_;
         unsigned int retraining_length_;
         LoadChangeEstimator load_change_estimator_;
         DeviceSpecification comp_dev_;
         
      };

   typedef std::tr1::shared_ptr<Algorithm> AlgorithmPtr;

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