/home/sebastian/gpudbms/trunk/hype-library/include/query_processing/node.hpp

Go to the documentation of this file.

#pragma once

#include <map>

#include <core/scheduling_decision.hpp>

#include <boost/shared_ptr.hpp>
#include <core/specification.hpp>
#include <query_processing/typed_operator.hpp>
#include <util/get_name.hpp>

namespace hype {
    namespace queryprocessing {

        //forward declaration
        class Node;
        //forward declaration
        template <typename Type>
        class TypedNode;

        template <typename Type>
        class PhysicalQueryPlan;

        //make Operator Mapper a singleton!
        //when OperatorMapper is instanciated, add second tempel argument where user has to specify a function that returns the Physical_Operator_Map;

        //OperatorMapper<TablePtr,initFunction> mapper;
        //boost::function<std::map<std::string,boost::function<boost::shared_ptr<TypedOperator<Type> > (const stemod::SchedulingDecision&)> > function> ()>
        //each node has to get one

        template <typename Type>
        struct OperatorMapper_Helper_Template {
            typedef Type type;
            typedef TypedNode<Type> TypedLogicalNode;
            typedef boost::shared_ptr<TypedLogicalNode> TypedNodePtr;
            //typedef TypedOperator<Type> TypedOperator;
            typedef boost::shared_ptr<TypedOperator<Type> > TypedOperatorPtr;
            typedef boost::function < TypedOperatorPtr(TypedLogicalNode&, const hype::SchedulingDecision&, TypedOperatorPtr, TypedOperatorPtr) > Create_Typed_Operator_Function;
            typedef std::map<std::string, Create_Typed_Operator_Function> Physical_Operator_Map;
            typedef boost::shared_ptr<Physical_Operator_Map> Physical_Operator_Map_Ptr;
            //typedef boost::function<Physical_Operator_Map_Ptr ()> Map_Init_Function;
            typedef Physical_Operator_Map_Ptr(Map_Init_Function)();
            typedef boost::shared_ptr<PhysicalQueryPlan<Type> > PhysicalQueryPlanPtr;
        };

        template <typename Type, typename OperatorMapper_Helper_Template<Type>::Map_Init_Function& function>
        class OperatorMapper {
        public:
            //typedef boost::shared_ptr<boost::shared_ptr<TypedOperator<Type> > > (*Create_Typed_Operator_Function)(const stemod::SchedulingDecision& sched_dec);
            //typedef boost::function<boost::shared_ptr<TypedOperator<Type> > (const stemod::SchedulingDecision&)> Create_Typed_Operator_Function_t;
            //typedef std::map<std::string,Create_Typed_Operator_Function_t> Physical_Operator_Map;

            typedef typename OperatorMapper_Helper_Template<Type>::Create_Typed_Operator_Function Create_Typed_Operator_Function;
            typedef typename OperatorMapper_Helper_Template<Type>::Physical_Operator_Map Physical_Operator_Map;
            typedef typename OperatorMapper_Helper_Template<Type>::Physical_Operator_Map_Ptr Physical_Operator_Map_Ptr;
            typedef typename OperatorMapper_Helper_Template<Type>::Map_Init_Function Map_Init_Function;
            //typedef typename OperatorMapper_Helper_Template<Type>::TypedOperator TypedOperator;
            typedef typename OperatorMapper_Helper_Template<Type>::TypedOperatorPtr TypedOperatorPtr;
            typedef typename OperatorMapper_Helper_Template<Type>::TypedLogicalNode TypedLogicalNode;
            typedef typename OperatorMapper_Helper_Template<Type>::TypedNodePtr TypedNodePtr;


            static const Physical_Operator_Map_Ptr static_algorithm_name_to_physical_operator_map_ptr; //=function();

            OperatorMapper() {
            } //: algorithm_name_to_physical_operator_map_(){}

            TypedOperatorPtr getPhysicalOperator(TypedLogicalNode& logical_node, const hype::Tuple& features_of_input_dataset, TypedOperatorPtr left_child, TypedOperatorPtr right_child, DeviceTypeConstraint dev_constr) const {
                const std::string& operation_name = logical_node.getOperationName();

                OperatorSpecification op_spec(operation_name,
                        features_of_input_dataset,
                        //parameters are the same, because in the query processing engine, we model copy oeprations explicitely, so the copy cost have to be zero
                        hype::PD_Memory_0, //input data is in CPU RAM
                        hype::PD_Memory_0); //output data has to be stored in CPU RAM

                //DeviceConstraint dev_constr;

                hype::SchedulingDecision sched_dec = hype::Scheduler::instance().getOptimalAlgorithm(op_spec, dev_constr);
                //find operation name in map
                typename Physical_Operator_Map::iterator it = static_algorithm_name_to_physical_operator_map_ptr->find(sched_dec.getNameofChoosenAlgorithm());
                if (it == static_algorithm_name_to_physical_operator_map_ptr->end()) {
                    std::cout << "[HyPE library] FATAL Error! " << typeid (OperatorMapper<Type, function>).name() << ": Missing entry in PhysicalOperatorMap for Algorithm '"
                            << sched_dec.getNameofChoosenAlgorithm() << "'" << std::endl;
                    exit(-1);
                }
                TypedOperatorPtr physical_operator;
                //call create function
                if (it->second) {
                    physical_operator = it->second(logical_node, sched_dec, left_child, right_child);
                } else {
                    std::cout << "[HyPE library] FATAL Error! Invalid Function Pointer in OperationMapper::getPhysicalOperator()" << std::endl;
                    exit(-1);
                }
                //return physical operator
                return physical_operator;
            }
            //insert map definition here
            //Physical_Operator_Map algorithm_name_to_physical_operator_map_;
        };

        template <typename Type, typename OperatorMapper_Helper_Template<Type>::Map_Init_Function& function>
        const typename OperatorMapper<Type, function>::Physical_Operator_Map_Ptr OperatorMapper<Type, function>::static_algorithm_name_to_physical_operator_map_ptr = function();



        //for logical plan, create derived class, which gets as template argument the Types of the corresponding physical Operators

        class Node {
        public:
            typedef boost::shared_ptr<Node> NodePtr;

            Node(DeviceConstraint dev_constr = DeviceConstraint()) : parent_(), left_(), right_(), level_(0), dev_constr_(dev_constr) {

            }

            /*
            Node(NodePtr parent) : parent_(parent), left_(), right_(), level_(0){

            }

            Node(NodePtr parent, NodePtr left, NodePtr right) : parent_(parent), left_(left), right_(right), level_(0){

            }*/

            virtual ~Node() {
            }

            bool isRoot() const {
                if (parent_.get() == NULL) return true;
                return false;
            }

            bool isLeaf() const {
                if (left_.get() == NULL && right_.get() == NULL) return true;
                return false;
            }

            const NodePtr getLeft() const {
                return left_;
            }

            const NodePtr getRight() const {
                return right_;
            }

            const NodePtr getParent() const{
                return parent_;
            }
            
            unsigned int getLevel() {
                return level_;
            }

            void setLevel(unsigned int level) {
                level_ = level;
            }

            virtual unsigned int getOutputResultSize() const = 0;

            virtual double getSelectivity() const = 0;

            virtual std::string getOperationName() const = 0;

            virtual std::string toString(bool verbose=false) const{
                if(verbose){
                        return this->getOperationName();
                        //return this->getOperationName()+std::string("\t")+util::getName(this->dev_constr_);                
                }else{
                        return this->getOperationName();               
                }
            }
            
            //const std::string& getOperationName() const;

            void setLeft(NodePtr left) {
                left_ = left;
                //left->setParent(left_);
            }

            void setRight(NodePtr right) {
                right_ = right;
                //right->setParent(right_);
            }

            void setParent(NodePtr parent) {
                parent_ = parent;
            }

            const DeviceConstraint& getDeviceConstraint() const {
                return this->dev_constr_;
            }

        protected:
            NodePtr parent_;
            NodePtr left_;
            NodePtr right_;
            unsigned int level_;
            DeviceConstraint dev_constr_;
            //std::string operation_name_;
        };
        
//        std::string Node::toString(bool) const{
//            return this->getOperationName();
//        }

        typedef Node::NodePtr NodePtr;

        /*
        Automatic Processing Device Selector
        AProDeS

        Automatic Processing Device Selector for Coprocessing
        AProDeSCo*/

        template <typename Type>
        class TypedNode : public Node {
        public:
            typedef Type NodeElementType;
            typedef typename OperatorMapper_Helper_Template<Type>::Physical_Operator_Map Physical_Operator_Map;
            typedef typename OperatorMapper_Helper_Template<Type>::Physical_Operator_Map_Ptr Physical_Operator_Map_Ptr;
            typedef typename OperatorMapper_Helper_Template<Type>::TypedOperatorPtr TypedOperatorPtr;

            TypedNode(DeviceConstraint dev_constr) : Node(dev_constr) {

            }

            virtual TypedOperatorPtr getOptimalOperator(TypedOperatorPtr left_child = NULL, TypedOperatorPtr right_child = NULL, DeviceTypeConstraint dev_constr = ANY_DEVICE) = 0;
            virtual Physical_Operator_Map_Ptr getPhysical_Operator_Map() = 0;

            virtual ~TypedNode() {
            }

        };

        template <typename Type, typename OperatorMapper_Helper_Template<Type>::Map_Init_Function& function>
        class TypedNode_Impl : public TypedNode<Type> {
        public:

            typedef typename TypedNode<Type>::Physical_Operator_Map Physical_Operator_Map;
            typedef typename TypedNode<Type>::Physical_Operator_Map_Ptr Physical_Operator_Map_Ptr;
            typedef typename TypedNode<Type>::TypedOperatorPtr TypedOperatorPtr;
            //typedef OperatorMapper<Type,function> OperatorMapper;

            TypedNode_Impl(bool use_selectivity_estimation = false, DeviceConstraint dev_constr = DeviceConstraint()) : TypedNode<Type>(dev_constr), operator_mapper_(), use_selectivity_estimation_(use_selectivity_estimation) {
                customSelectivity = -1;
            }

            virtual ~TypedNode_Impl() {
            }

            virtual TypedOperatorPtr getOptimalOperator(TypedOperatorPtr left_child, TypedOperatorPtr right_child, DeviceTypeConstraint dev_constr) {
                hype::Tuple t;
                if (this->left_) { //if left child is valid (has to be by convention!), add input data size
                    t.push_back(this->left_->getOutputResultSize());
                    if (this->right_) { //if right child is valid (not null), add input data size for it as well
                        t.push_back(this->right_->getOutputResultSize());
                    }
                }
                if (use_selectivity_estimation_)
                    t.push_back(this->getSelectivity()); //add selectivity of this operation, when use_selectivity_estimation_ is true

                return operator_mapper_.getPhysicalOperator(*this, t, left_child, right_child, dev_constr); //this->getOperationName(), t, left_child, right_child);
            }

            virtual Physical_Operator_Map_Ptr getPhysical_Operator_Map() {
                return OperatorMapper<Type, function>::static_algorithm_name_to_physical_operator_map_ptr;
            }

            double getSelectivity() const {
                if (customSelectivity != -1) {
                    return customSelectivity;
                } else {
                    return getCalculatedSelectivity();
                }
            }

            void setSelectivity(double selectivity) {
                customSelectivity = selectivity;
            }
            //boost::shared_ptr<> toPhysicalNode();

        protected:
            OperatorMapper<Type, function> operator_mapper_;
            bool use_selectivity_estimation_;
            double customSelectivity;

            virtual double getCalculatedSelectivity() const {
                return 0.1;
            }
        };

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