scheduler.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 <iostream>
#include <string>
#include <vector>
#include <core/operation.hpp>
#include <core/time_measurement.hpp>
#include <core/measurementpair.hpp>
#include <core/specification.hpp>
#include <query_processing/virtual_processing_device.hpp>

namespace hype{
   namespace core{

      class Scheduler{
         public:

            typedef std::map<std::string,std::tr1::shared_ptr<Operation> > MapNameToOperation;

            static Scheduler& instance();

            /* \brief adds an Algorithm to the AlgorithmPool of operation name_of_operation.
             * \details If the specified operation does not exist, it is created. Multiple calls to addAlgorithm
             *  with the same Operation name will add the respective algorithms to the algorithm pool of the specified Operation    
             * \param name_of_operation name of the operation, where the algorithm belongs to 
             * \param name_of_algorithm Name of Algorithm to be created
             * \param name_of_statistical_method assigns the StatisticalMethod name_of_statistical_method to the new Algorithm
             * \param name_of_recomputation_strategy assigns the RecomputationHeuristic name_of_recomputation_strategy to the new Algorithm
             * \return returns true on success and false otherwise   
             */      
//          bool addAlgorithm(const std::string& name_of_operation,
//                            const std::string& name_of_algorithm, 
//                            ComputeDevice comp_dev,                            
//                            const std::string& name_of_statistical_method, 
//                            const std::string& name_of_recomputation_strategy);

            bool addAlgorithm(const AlgorithmSpecification& alg_spec, const DeviceSpecification& dev_spec);

            bool setOptimizationCriterion(const std::string& name_of_operation,
                                          const std::string& name_of_optimization_criterion);
            bool setStatisticalMethod(const std::string& name_of_algorithm,
                                      const std::string& name_of_statistical_method);
            bool setRecomputationHeuristic(const std::string& name_of_algorithm,
                                           const std::string& name_of_recomputation_strategy);

            /* \brief Returns a Scheduling Decision, which contains the name of the estimated optimal Algorithm 
             *  w.r.t. the user specified optimization criterion
             * \param name_of_operation name of the operation, where the optimal algorithm is requested
             * \param input_values features of the input dataset, which is needed to compute estimated execution times 
             for all algortihms of the specified operation
             * \return SchedulingDecision, which contains the suggested algortihm for the specified information   
             */
            //const SchedulingDecision getOptimalAlgorithmName(const std::string& name_of_operation, const Tuple& input_values, DeviceTypeConstraint dev_constr = ANY_DEVICE);

            const SchedulingDecision getOptimalAlgorithm(const OperatorSpecification& op_spec, const DeviceConstraint& dev_constr);

            /* \brief adds an observed MeasurementPair to the algorithm previously choosen by getOptimalAlgorithmName.
             * \param name_of_algorithm name of the algorithm the MeasurementPair belongs to
             * \param mp the observed MeasurementPair
             * \return Scheduling Decision, which recommends the application the optimal Algorithm w.r.t. the specified 
             *  operation and features of the input data set   
             */
            //bool addObservation(const std::string& name_of_algorithm, const MeasurementPair& mp);
            
            bool addObservation(const SchedulingDecision& sched_dec, const double& measured_execution_time);

            const AlgorithmPtr getAlgorithm(const std::string& name_of_algorithm);
            /* \brief request an Estimated Execution Time from HyPE for an algorithm for a certain operator
             * \param op_spec OperatorSpecification, contains all available information about the operator to execute
             * \param alg_name algorithm name
             * \return estimated execution time
             */      
            EstimatedTime getEstimatedExecutionTime(const OperatorSpecification& op_spec, const std::string& alg_name);
                                
                                void print();
         private:
            Scheduler();
            Scheduler(const Scheduler&);
            Scheduler& operator= (const Scheduler&);

            //void addOperation(std::string operation_name);      

            MapNameToOperation map_operationname_to_operation_;
            StatisticalMethodMap map_statisticalmethodname_to_statisticalmethod_;

            public:
            class ProcessingDevices{
               public:
               typedef std::map<ProcessingDeviceID,queryprocessing::VirtualProcessingDevicePtr> Devices;
               
               ProcessingDevices();
               
               queryprocessing::VirtualProcessingDevicePtr getProcessingDevice(ProcessingDeviceID);
               
               bool addDevice(const DeviceSpecification&);
               
               bool exists(const DeviceSpecification&) const throw();
               
               const Devices& getDevices() const throw();
               
               bool addSchedulingDecision(const SchedulingDecision&);               

               bool removeSchedulingDecision(const SchedulingDecision&);   
                                 
               void print() const throw();                  
               private:
                  Devices virt_comp_devs_;
            };
            

            ProcessingDevices& getProcessingDevices(); 
            
            private:
            ProcessingDevices proc_devs_;

      };

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