/home/sebastian/gpudbms/trunk/hype-library/include/core/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