/home/sebastian/gpudbms/trunk/hype-library/include/core/specification.hpp

Go to the documentation of this file.

#pragma once

#include <config/global_definitions.hpp>
#include <config/configuration.hpp>
#include <core/time_measurement.hpp>
#include <string>

namespace hype{
        namespace core{
        

                //ProcessingDeviceMemoryID getMemory(ProcessingDeviceID );
                //std::vector<ProcessingDeviceID> getProcessingDevices(ProcessingDeviceMemoryID);

        class HYPE_EXPORT AlgorithmSpecification{
                public:
                AlgorithmSpecification(const std::string& alg_name,
                                                                          const std::string& op_name,
                                                                          StatisticalMethod stat_meth = Least_Squares_1D,
                                                                          RecomputationHeuristic recomp_heur = Periodic,
                    OptimizationCriterion opt_crit = Runtime_Configuration::instance().getDefaultOptimizationCriterion());
                const std::string& getAlgorithmName() const throw();
                const std::string& getOperationName() const throw();
                const std::string getStatisticalMethodName() const throw();
                const std::string getRecomputationHeuristicName() const throw();
                const std::string getOptimizationCriterionName() const throw();         
                private:
                std::string alg_name_; 
                std::string op_name_;
                StatisticalMethod stat_meth_;
                RecomputationHeuristic recomp_heur_;
                OptimizationCriterion opt_crit_;
        };


        
        struct HYPE_EXPORT OperatorSpecification{
        public:
                OperatorSpecification(const std::string& operator_name, 
                                                                         const Tuple& feature_vector,
                                                                         ProcessingDeviceMemoryID location_of_input_data,
                                                                         ProcessingDeviceMemoryID location_for_output_data);
                const std::string& getOperatorName() const throw();
                const Tuple& getFeatureVector() const throw();
                ProcessingDeviceMemoryID getMemoryLocation() const throw();
                private:
                std::string operator_name_;
                Tuple feature_vector_;
                ProcessingDeviceMemoryID location_of_input_data_;
                ProcessingDeviceMemoryID location_for_output_data_;
        };

        //member for each processing device
        struct HYPE_EXPORT DeviceSpecification{
                public:
                DeviceSpecification(ProcessingDeviceID pd,
                                                                  ProcessingDeviceType pd_t,
                                                                  ProcessingDeviceMemoryID pd_m);
                ProcessingDeviceID getProcessingDeviceID() const throw();
                ProcessingDeviceType getDeviceType() const throw();
                ProcessingDeviceMemoryID getMemoryID() const throw();
                operator ProcessingDeviceID(); 
                operator ProcessingDeviceType();
                operator ProcessingDeviceMemoryID();
                bool operator== (const DeviceSpecification&) const;
                
                private:
                ProcessingDeviceID pd_;
                ProcessingDeviceType pd_t_;
                ProcessingDeviceMemoryID pd_m_;
        };
        struct HYPE_EXPORT DeviceConstraint{
                public:
                DeviceConstraint(DeviceTypeConstraint dev_constr = ANY_DEVICE,
                                                          ProcessingDeviceMemoryID pd_mem_constr = PD_Memory_0);

                DeviceTypeConstraint getDeviceTypeConstraint() const; 

                operator DeviceTypeConstraint(); 
                operator ProcessingDeviceMemoryID();
                operator DeviceTypeConstraint() const; 
                operator ProcessingDeviceMemoryID() const;              
                private:
                DeviceTypeConstraint dev_constr_;
                ProcessingDeviceMemoryID pd_mem_constr_; //restrict to devices that use a certain memory

        };      
        

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