cuda_array.hpp

Go to the documentation of this file.

//*LB*
// Copyright (c) 2010, University of Bonn, Institute for Computer Science VI
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  * Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//  * Neither the name of the University of Bonn 
//    nor the names of its contributors may be used to endorse or promote
//    products derived from this software without specific prior written
//    permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//*LE*

#ifndef __CUDA_ARRAY_HPP__
#define __CUDA_ARRAY_HPP__

#include <cuv/basics/tensor.hpp>
#include <cuv/basics/matrix.hpp>

class cudaArray; // forward declaration of cudaArray so we do not need to include cuda headers here


namespace cuv
{
        template<class __value_type, class __memory_space_type, class __index_type = unsigned int >
        class cuda_array 
        :        public matrix<__value_type, __index_type>{
                public:
                  typedef __memory_space_type                                                             memory_space_type;
                  typedef matrix<__value_type, __index_type>                              base_type;            
                  typedef typename base_type::value_type                                          value_type;           
                  typedef typename base_type::index_type                                          index_type;           
                  typedef cuda_array<value_type,memory_space_type,index_type>  my_type;         
                  using base_type::m_width;    
                  using base_type::m_height;   
                  index_type m_depth;          

                private:
                  cudaArray*         m_ptr;   
                  unsigned int       m_dim;   

                public:
                  cuda_array(const index_type& height, const index_type& width, const index_type& depth=1, const unsigned int dim=1)
                          :base_type(height, width)
                          ,m_depth(depth)
                          ,m_ptr(NULL)
                          ,m_dim(dim)
                  {
                          alloc();
                  }

                  template<class S>
                  cuda_array(const tensor<value_type,S,row_major>& src, const unsigned int dim=1) 
                  :base_type(0, 0)
                  , m_ptr(NULL)
                  , m_dim(dim)
                  {
                          if(src.ndim()==2){
                                  m_height = src.shape()[0];
                                  m_width  = src.shape()[1];
                                  m_depth  = 1;
                          }else if(src.ndim()==3){
                                  m_depth  = src.shape()[0];
                                  m_height = src.shape()[1];
                                  m_width  = src.shape()[2];
                          }
                          alloc();
                          assign(src);
                  }
                  ~cuda_array(){ 
                          dealloc();
                  }
                  inline index_type w()const{return m_width;}           
                  inline index_type h()const{return m_height;}          
                  inline index_type d()const{return m_depth;}          
                  inline index_type n()const{return m_width*m_height*m_depth;}  
                  inline index_type dim()const{return m_dim; }          
                  inline       cudaArray* ptr()      {return m_ptr;}    
                  inline const cudaArray* ptr() const{return m_ptr;}    
                  void alloc();                                         
                  void dealloc();                                       

                  void assign(const tensor<__value_type,dev_memory_space,row_major>& src);  
                  void assign(const tensor<__value_type,host_memory_space,row_major>& src);

                  __value_type operator()(const __index_type& i, const __index_type& j)const;
        };
}

#endif /* __CUDA_ARRAY_HPP__ */