/home/sebastian/gpudbms/trunk/hype-library/include/hype.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 <core/specification.hpp>
#include <config/exports.hpp>

#include <core/algorithm_measurement.hpp>
#include <core/time_measurement.hpp>
#include <core/workload_generator.hpp>
#include <core/statistics_gatherer.hpp>
#include <core/scheduling_decision.hpp>
#include <core/report.hpp>

namespace hype{

        typedef core::AlgorithmMeasurement AlgorithmMeasurement;
        typedef core::Tuple Tuple;      
        typedef core::SchedulingDecision SchedulingDecision;
        typedef core::Offline_Algorithm Offline_Algorithm;
        typedef core::WorkloadGenerator WorkloadGenerator;
        typedef core::StatisticsGatherer StatisticsGatherer;
        typedef core::Report Report;    
        typedef core::AlgorithmSpecification AlgorithmSpecification;
        typedef core::OperatorSpecification OperatorSpecification;
        typedef core::DeviceSpecification DeviceSpecification;
        typedef core::DeviceConstraint DeviceConstraint;
        //typedef core::MeasurementPair MeasurementPair;                
        
        class HYPE_EXPORT Scheduler{
                public:
                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);
                                                                
                //addAlgorithm(AlgorithmSpecification,DeviceSpecification);
                //getOptAlgorithm(Tuple,std::string operation_name,DeviceConstraint dev_constr);                                                                
                                                                                
                                                                                
                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 true on success and false in case an error occured
                 */
                //bool addObservation(const std::string& name_of_algorithm, const MeasurementPair& mp);
                bool addObservation(const SchedulingDecision& sched_dec, const double& measured_execution_time);
                /* \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
                 */                     
                core::EstimatedTime getEstimatedExecutionTime(const OperatorSpecification& op_spec, const std::string& alg_name);
                private:
                Scheduler();
                Scheduler(const Scheduler&);
                Scheduler& operator=( const Scheduler& s );
        };
        
}; //end namespace hype

//namespace hype = hype;