unary_operator.hpp

Go to the documentation of this file.

#pragma once

//#include <core/scheduling_decision.hpp>

//#include <boost/shared_ptr.hpp>
#include <config/global_definitions.hpp>
#include <config/configuration.hpp>
#include <query_processing/typed_operator.hpp>

namespace hype {
    namespace queryprocessing {

        template <typename OperatorInputType, typename OperatorOutputType> //, typename TLogicalOperation>
        class UnaryOperator : public TypedOperator<OperatorOutputType> { //uses 1D Learning Method

        public:
            //typedef typename OperatorMapper_Helper_Template<OperatorOutputType>::TypedOperator TypedOperator;
            typedef typename OperatorMapper_Helper_Template<OperatorOutputType>::TypedOperatorPtr TypedOperatorPtr;
            //typedef typename OperatorMapper_Helper_Template<OperatorOutputType>::TypedNodePtr TypedNodePtr;

            //typedef TLogicalOperation LogicalOperationType;

            UnaryOperator(const hype::SchedulingDecision& sched_dec, TypedOperatorPtr child)
            : TypedOperator<OperatorOutputType>(sched_dec), child_(child) {
            }

            virtual ~UnaryOperator() {
            }

            OperatorInputType getInputData() {
                if (child_)
                    return child_->getResult();
                else
                    return OperatorInputType();
            }

            virtual bool run() {

                if (!hype::core::Runtime_Configuration::instance().isQueryChoppingEnabled() && child_) {
                    child_->run();
                }
                //execute this operator
                double begin = double(hype::core::getTimestamp());
                timeEstimated = double(this->getEstimatedExecutionTime().getTimeinNanoseconds());
                bool retVal = (*this)();
                timeNeeded = double( hype::core::getTimestamp()) - begin;
                return retVal;
            }

            virtual void print(unsigned int tree_level) const {
                for (unsigned int i = 0; i < tree_level; ++i) {
                    std::cout << "\t";
                }
                assert(!this->getFeatureValues().empty());
                std::cout << this->getAlgorithmName() << " ET: " << this->getEstimatedExecutionTime().getTimeinNanoseconds()
                        << "\tEC: " << this->getFeatureValues()[0]
                        << std::endl; // << " Features: " << this->getFeatureValues() << std::endl;
                if (child_) child_->print(tree_level + 1);
            }

            virtual void printResult(unsigned int tree_level) const {
                for (unsigned int i = 0; i < tree_level; ++i) {
                    std::cout << "\t";
                }
                assert(!this->getFeatureValues().empty());
                std::cout << this->getAlgorithmName() << " ET: " << timeEstimated
                        << "\tMT: " << timeNeeded
                        << "\tEE: " << 1 - (timeEstimated / timeNeeded)
                        << "\tEC: " << this->getFeatureValues()[0];
                if (this->getResultSize() != -1) {
                    std::cout << "\tRR: " << this->getResultSize();
                }
                        std::cout << std::endl;
                if (child_) child_->printResult(tree_level + 1);
            }

            virtual double getRecursiveExecutionTimeInNanoseconds() {
                double executiontime = this->getEstimatedExecutionTime().getTimeinNanoseconds();
                if (executiontime < 0) {
                    executiontime = 0;
                }
                if (child_) {
                    executiontime += child_->getRecursiveExecutionTimeInNanoseconds();
                }
                return executiontime;
            }

            /*
            virtual std::list<TypedOperator<OperatorOutputType>& > getOperatorQueue(){
                    std::list<TypedOperator<OperatorOutputType>& > list = child_->getOperatorQueue();
                    list.push_front(*this);
                    return list;
            }*/
        private:
            double timeNeeded;
            double timeEstimated;

            boost::shared_ptr<TypedOperator<OperatorInputType> > child_;
            //boost::shared_ptr<TypedOperator<OperatorOutputType> > succsessor_;
        };

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