/home/sebastian/gpudbms/trunk/cogadb/include/gpu/gpu_typed_base_column.hpp

Go to the documentation of this file.

#pragma once
#ifndef __CUDACC__
        #error "cannot compile header file __FILE__: you have to use nvcc!"
#endif

#include <gpu/gpu_base_column.hpp>
#include <gpu/gpu_positionlist.hpp>
#include <thrust/device_vector.h>
#include <thrust/gather.h>
#include <thrust/functional.h>

namespace CoGaDB{
        namespace gpu{          
                
                template<typename T>
                class GPU_Typed_Base_Column : public GPU_Base_Column{
                        public:
                        explicit GPU_Typed_Base_Column(const std::string& name, AttributeType db_type);

                        virtual ~GPU_Typed_Base_Column();
                        
                        bool insert_from_host_memory(const std::vector<T>& host_column);
                        bool insert_from_device_memory_in_host_vector(std::vector<T>& host_column); //not const reference, because routine inserts directly in host vector
                        virtual bool insert(const boost::any& new_Value);
                        virtual bool update(TID tid, const boost::any& new_Value);
                        virtual bool remove(TID tid);

                        virtual const boost::any get(TID tid); //not const, because operator [] does not provide const return type and the child classes rely on []

                        virtual bool add(const boost::any& new_Value);
                        //vector addition between columns                       
                        virtual bool add(shared_pointer_namespace::shared_ptr<GPU_Base_Column> column);

                        virtual bool minus(const boost::any& new_Value);
                        virtual bool minus(shared_pointer_namespace::shared_ptr<GPU_Base_Column> column);       

                        virtual bool multiply(const boost::any& new_Value);
                        virtual bool multiply(shared_pointer_namespace::shared_ptr<GPU_Base_Column> column);

                        virtual bool division(const boost::any& new_Value);     
                        virtual bool division(shared_pointer_namespace::shared_ptr<GPU_Base_Column> column);    

                        virtual const shared_pointer_namespace::shared_ptr<GPU_Base_Column> copy() const;
                        virtual const shared_pointer_namespace::shared_ptr<GPU_Base_Column> materialize(shared_pointer_namespace::shared_ptr<GPU_Positionlist> pos_list) const; 

                        virtual void print() const throw();
                        virtual size_t size() const throw();
                        virtual const std::type_info& type() const throw();
//                      AttributeType getType() const throw();
//                      const std::string getName() const throw();

                        thrust::device_vector<T>& getContent();
                        friend const ColumnPtr copy_column_device_to_host(GPU_Base_ColumnPtr device_column);

                        protected:
                        thrust::device_vector<T> data_;
                };              
                
                        template<typename T>
                        GPU_Typed_Base_Column<T>::GPU_Typed_Base_Column(const std::string& name, AttributeType db_type) : GPU_Base_Column(name,db_type), data_(){
                                
                        }

                        template<typename T>
                        GPU_Typed_Base_Column<T>::~GPU_Typed_Base_Column(){

                        }
                        template<typename T>                    
                        bool GPU_Typed_Base_Column<T>::insert_from_host_memory(const std::vector<T>& host_column){
                                //TODO: add time measurement
                                data_=host_column;
                                return true;
                        }
                        template<typename T>                    
                        bool GPU_Typed_Base_Column<T>::insert_from_device_memory_in_host_vector(std::vector<T>& host_column){
                                //TODO: add time measurement
                                host_column.clear();
                                thrust::host_vector<T> t(data_.begin(),data_.end());
                                host_column.insert(host_column.begin(),t.begin(),t.end());
                                //host_column.insert(host_column.begin(),data_.begin(),data_.end());
                                return true;
                        }

                        template<typename T>            
                        bool GPU_Typed_Base_Column<T>::insert(const boost::any& new_Value){
                                return false;
                        }

                        template<typename T>                    
                        bool GPU_Typed_Base_Column<T>::update(TID tid, const boost::any& new_Value){
                                return false;
                        }

                        template<typename T>                    
                        bool GPU_Typed_Base_Column<T>::remove(TID tid){
                                return false;
                        }

                        template<typename T>
                        const boost::any GPU_Typed_Base_Column<T>::get(TID tid){
                                return boost::any(data_[tid]);
                        }


                        template<class Type>
                        bool GPU_Typed_Base_Column<Type>::add(const boost::any& new_value){
                                if(new_value.empty()) return false;
                                if(typeid(Type)!=new_value.type()){
                                         return false;
                                }
                                Type value = boost::any_cast<Type>(new_value);
                                //using thrust::placeholders;
                                //the third agument is an unnamed functor!, see 
                                //http://stackoverflow.com/questions/9671104/how-to-decrement-each-element-of-a-device-vector-by-a-constant for details
                                thrust::for_each(this->data_.begin(), this->data_.end(), thrust::placeholders::_1 += value); 
                                return true;
                        }
        

                        
                        template<class Type>
                        bool GPU_Typed_Base_Column<Type>::add(shared_pointer_namespace::shared_ptr<GPU_Base_Column> column){
                                //std::transform ( first, first+5, second, results, std::plus<int>() );         
                                shared_pointer_namespace::shared_ptr<GPU_Typed_Base_Column<Type> > typed_column = shared_pointer_namespace::static_pointer_cast<GPU_Typed_Base_Column<Type> >(column);
                                if(!typed_column) return false;
                                if(this->size()!=typed_column->size()) return false;

                                thrust::transform(this->data_.begin(), this->data_.end(), typed_column->data_.begin(), this->data_.begin(), thrust::plus<Type>());
                
                                return true;
                        }



                        template<class Type>
                        bool GPU_Typed_Base_Column<Type>::minus(const boost::any& new_value){
                                //shared_pointer_namespace::shared_ptr<GPU_Typed_Base_Column<Type> > typed_column = shared_pointer_namespace::static_pointer_cast<GPU_Typed_Base_Column<Type> >(column);        
                                if(new_value.empty()) return false;
                                if(typeid(Type)!=new_value.type()){
                                         return false;
                                }
                                Type value = boost::any_cast<Type>(new_value);
                                using namespace thrust::placeholders;
                                thrust::for_each(this->data_.begin(), this->data_.end(), thrust::placeholders::_1 -= value);
                                return true;
                        }
        
                        template<class Type>
                        bool GPU_Typed_Base_Column<Type>::minus(shared_pointer_namespace::shared_ptr<GPU_Base_Column> column){
                                //std::transform ( first, first+5, second, results, std::plus<int>() );         
                                //std::transform ( first, first+5, second, results, std::plus<int>() );         
                                shared_pointer_namespace::shared_ptr<GPU_Typed_Base_Column<Type> > typed_column = shared_pointer_namespace::static_pointer_cast<GPU_Typed_Base_Column<Type> >(column);
                                if(!typed_column) return false;
                                if(this->size()!=typed_column->size()) return false;

                        thrust::transform(this->data_.begin(), this->data_.end(), typed_column->data_.begin(), this->data_.begin(), thrust::minus<Type>());
                
                                return true;
                        }       


                        template<class Type>
                        bool GPU_Typed_Base_Column<Type>::multiply(const boost::any& new_value){
                                if(new_value.empty()) return false;
                                if(typeid(Type)!=new_value.type()){
                                         return false;
                                }
                                Type value = boost::any_cast<Type>(new_value);
                                //using thrust::placeholders;
                                thrust::for_each(this->data_.begin(), this->data_.end(), thrust::placeholders::_1 *= value);
                                return true;
                        }
        
                        template<class Type>
                        bool GPU_Typed_Base_Column<Type>::multiply(GPU_Base_ColumnPtr column){
                                //std::transform ( first, first+5, second, results, std::plus<int>() );         
                                shared_pointer_namespace::shared_ptr<GPU_Typed_Base_Column<Type> > typed_column = shared_pointer_namespace::static_pointer_cast<GPU_Typed_Base_Column<Type> >(column);
                                if(!typed_column) return false;
                                if(this->size()!=typed_column->size()) return false;

                        thrust::transform(this->data_.begin(), this->data_.end(), typed_column->data_.begin(), this->data_.begin(), thrust::multiplies<Type>());
                
                                return true;
                        }



                        template<class Type>
                        bool GPU_Typed_Base_Column<Type>::division(const boost::any& new_value){
                                if(new_value.empty()) return false;
                                if(typeid(Type)!=new_value.type()){
                                         return false;
                                }
                                Type value = boost::any_cast<Type>(new_value);
                                //using thrust::placeholders;
                                thrust::for_each(this->data_.begin(), this->data_.end(), thrust::placeholders::_1 /= value);
                                return true;
                        }
        
                        template<class Type>
                        bool GPU_Typed_Base_Column<Type>::division(GPU_Base_ColumnPtr column){
                                //std::transform ( first, first+5, second, results, std::plus<int>() );         
                                shared_pointer_namespace::shared_ptr<GPU_Typed_Base_Column<Type> > typed_column = shared_pointer_namespace::static_pointer_cast<GPU_Typed_Base_Column<Type> >(column);
                                if(!typed_column) return false;
                                if(this->size()!=typed_column->size()) return false;

                        thrust::transform(this->data_.begin(), this->data_.end(), typed_column->data_.begin(), this->data_.begin(), thrust::divides<Type>());

                                return true;
                        }

                        //total tempalte specializations, because numeric computations are undefined on strings 
                        template<>
                        inline bool GPU_Typed_Base_Column<std::string>::add(const boost::any&){ return false;   }
                        template<>
                        inline bool GPU_Typed_Base_Column<std::string>::add(GPU_Base_ColumnPtr){ return false;  }

                        template<>
                        inline bool GPU_Typed_Base_Column<std::string>::minus(const boost::any&){ return false; }
                        template<>
                        inline bool GPU_Typed_Base_Column<std::string>::minus(GPU_Base_ColumnPtr){ return false;        }


                        template<>
                        inline bool GPU_Typed_Base_Column<std::string>::multiply(const boost::any&){ return false;      }
                        template<>
                        inline bool GPU_Typed_Base_Column<std::string>::multiply(GPU_Base_ColumnPtr){ return false;     }
        
                        template<>
                        inline bool GPU_Typed_Base_Column<std::string>::division(const boost::any&){ return false;      }
                        template<>
                        inline bool GPU_Typed_Base_Column<std::string>::division(GPU_Base_ColumnPtr){ return false;     }


                        template<typename T>
                        const GPU_Base_ColumnPtr GPU_Typed_Base_Column<T>::copy() const{
                                return GPU_Base_ColumnPtr(new GPU_Typed_Base_Column<T>(*this));
                        }

                        template<typename T>                    
                        const shared_pointer_namespace::shared_ptr<GPU_Base_Column> GPU_Typed_Base_Column<T>::materialize(shared_pointer_namespace::shared_ptr<GPU_Positionlist> pos_list) const{
                                GPU_Typed_Base_Column<T>* new_column = new GPU_Typed_Base_Column<T>(this->name_,this->db_type_);
                                
                                shared_pointer_namespace::shared_ptr<Impl_GPU_Positionlist> dev_pos_list = shared_pointer_namespace::static_pointer_cast<Impl_GPU_Positionlist> (pos_list);
                                
                                thrust::device_vector<T>& data = new_column->getContent(); //empty device vector
                                thrust::device_vector<TID>& tids = dev_pos_list->getContent(); //map with indeces
                                
                                data.resize(tids.size());
                                //std::cout << "Calling Gather..." << std::endl;
                                
                            //std::cout << "TIDS:.." << std::endl;
                                 thrust::copy(tids.begin(), tids.end(), std::ostream_iterator<int>(std::cout, "\n"));
                                 //std::cout << "data_:.." << std::endl;
                                 thrust::copy(data_.begin(), data_.end(), std::ostream_iterator<int>(std::cout, "\n"));                          

                                 thrust::gather(tids.begin(), tids.end(),
                                                 this->data_.begin(), //from this object
                                                 data.begin()); //from created column
                 //std::cout << "new data:.." << std::endl;
                                 thrust::copy(data.begin(), data.end(), std::ostream_iterator<int>(std::cout, "\n"));                                    
                                                 
                                return GPU_Base_ColumnPtr(new_column);
                        }       

                        template<typename T>
                        void GPU_Typed_Base_Column<T>::print() const throw(){
                                thrust::host_vector<T> v(data_);
                                std::cout << "GPU Column: " << name_ << " of Type: " << typeid(T).name() << std::endl;
                                std::cout << "Values: (" << v.size() << ")"  << std::endl;
                                for(unsigned int i=0;i<v.size();i++){
                                        std::cout << v[i] << std::endl;
                                }
                        }

                        template<typename T>                    
                        size_t GPU_Typed_Base_Column<T>::size() const throw(){
                                return data_.size();
                        }

                        template<typename T>                    
                        const std::type_info& GPU_Typed_Base_Column<T>::type() const throw(){
                                return typeid(T);
                        }
                        
                        template<typename T>    
                        thrust::device_vector<T>& GPU_Typed_Base_Column<T>::getContent(){
                                return this->data_;
                        }

//                      template<typename T>
//                      AttributeType GPU_Typed_Base_Column<T>::getType() const throw(){
//                              return this->db_type_;
//                      }
//                      
//                      template<typename T>
//                      const std::string GPU_Typed_Base_Column<T>::getName() const throw(){
//                              return this->name_;
//                      }
                
                
        }; //end namespace gpu
}; //end namespace CogaDB