processing_device.hpp

Go to the documentation of this file.

#pragma once

#include <list>

#include <config/global_definitions.hpp>

#include <query_processing/operator.hpp>


//g++ compiler workaround for boost thread!
#ifdef __GNUC__
#pragma GCC visibility push(default)
#endif
#include <boost/thread.hpp>
#include <boost/bind.hpp>
//g++ compiler workaround for boost thread!
#ifdef __GNUC__
#pragma GCC visibility pop
#endif

namespace hype
{
   namespace queryprocessing
   {

      class ProcessingDevice
      {

         public:
            ProcessingDevice();

            bool addOperator(OperatorPtr op);

            void start();
            void stop();
            void run(); //thread
            bool isIdle();
            double getEstimatedTimeUntilIdle();
            double getTotalProcessingTime();
         private:
            ProcessingDevice(const ProcessingDevice& pd);
            ProcessingDevice& operator=(const ProcessingDevice&);
            double getEstimatedTimeUntilOperatorCompletion();

            typedef std::list<OperatorPtr> OperatorList;
            OperatorList operators_;
            boost::condition_variable new_operator_available_;
            boost::condition_variable operator_queue_full_;       
            boost::mutex operator_mutex_;
            boost::thread thread_;
            uint64_t start_timestamp_of_currently_executed_operator_;
            double estimated_execution_time_of_currently_executed_operator_;
            bool operator_in_execution_;
            double estimated_execution_time_for_operators_in_queue_to_complete_;
            double total_measured_execution_time_for_all_executed_operators_; //used to determine how processing devices were utilized
      };
      ProcessingDevice& getProcessingDevice(const hype::core::DeviceSpecification& dev); //can later be queried by using algorithmptr->getDeviceSpecification();



   }; //end namespace queryprocessing
}; //end namespace hype