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